fixes

Author: disintegrator

server/internal/background/deployments.go

@@ -184,28 +184,6 @@ func ProcessDeploymentWorkflow(ctx workflow.Context, params ProcessDeploymentWor
 		)
 	}
 
-	// Trigger project-scoped functions reaper workflow after successful deployment
-	// This runs asynchronously and doesn't block the deployment workflow
-	if finalStatus == "completed" {
-		logger.Info(
-			"starting project-scoped function reaper",
-			string(attr.ProjectIDKey), params.ProjectID,
-			string(attr.DeploymentIDKey), params.DeploymentID,
-		)
-		_, err = ExecuteProjectFunctionsReaperChildWorkflow(ctx, params.ProjectID)
-		// Many deployments can run in parallel in a given project but only one
-		// reaper should be active at a time, so we ignore the already started
-		// error if we get that back.
-		if err != nil && !temporal.IsWorkflowExecutionAlreadyStartedError(err) {
-			logger.Error(
-				"failed to start project-scoped functions reaper workflow",
-				"error", err.Error(),
-				string(attr.ProjectIDKey), params.ProjectID,
-				string(attr.DeploymentIDKey), params.DeploymentID,
-			)
-		}
-	}
-
 	return &ProcessDeploymentWorkflowResult{
 		ProjectID:    params.ProjectID,
 		DeploymentID: params.DeploymentID,

server/internal/background/functions_reaper.go

@@ -1,10 +1,12 @@
 package background
 
 import (
+	"context"
 	"fmt"
 	"time"
 
 	"go.temporal.io/api/enums/v1"
+	"go.temporal.io/sdk/client"
 	"go.temporal.io/sdk/temporal"
 	"go.temporal.io/sdk/workflow"
 
@@ -23,18 +25,17 @@ type FunctionsReaperWorkflowResult struct {
 	Errors     int
 }
 
-func ExecuteProjectFunctionsReaperChildWorkflow(ctx workflow.Context, projectID uuid.UUID) (workflow.ChildWorkflowFuture, error) {
-	ctx = workflow.WithChildOptions(ctx, workflow.ChildWorkflowOptions{
-		WorkflowID:            "v1:functions-reaper:" + projectID.String(),
-		TaskQueue:             string(TaskQueueMain),
-		WorkflowIDReusePolicy: enums.WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE_FAILED_ONLY,
-		WorkflowRunTimeout:    time.Minute * 10,
-	})
-
-	return workflow.ExecuteChildWorkflow(ctx, FunctionsReaperWorkflow, FunctionsReaperWorkflowParams{
+func ExecuteProjectFunctionsReaperWorkflow(ctx context.Context, temporalClient client.Client, projectID uuid.UUID) (client.WorkflowRun, error) {
+	return temporalClient.ExecuteWorkflow(ctx, client.StartWorkflowOptions{
+		ID:                       "v1:functions-reaper:" + projectID.String(),
+		TaskQueue:                string(TaskQueueMain),
+		WorkflowIDConflictPolicy: enums.WORKFLOW_ID_CONFLICT_POLICY_USE_EXISTING,
+		WorkflowIDReusePolicy:    enums.WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE,
+		WorkflowRunTimeout:       time.Minute * 2,
+	}, ProcessDeploymentWorkflow, FunctionsReaperWorkflowParams{
 		Scope:     activities.FunctionsReaperScopeProject,
 		ProjectID: uuid.NullUUID{UUID: projectID, Valid: projectID != uuid.Nil},
-	}), nil
+	})
 }
 
 func FunctionsReaperWorkflow(ctx workflow.Context, params FunctionsReaperWorkflowParams) (*FunctionsReaperWorkflowResult, error) {

server/internal/deployments/impl.go

@@ -36,6 +36,7 @@ import (
 	"github.com/speakeasy-api/gram/server/internal/packages/semver"
 	"github.com/speakeasy-api/gram/server/internal/thirdparty/posthog"
 	"go.temporal.io/sdk/client"
+	"go.temporal.io/sdk/temporal"
 )
 
 type Service struct {
@@ -846,6 +847,17 @@ func (s *Service) resolvePackages(ctx context.Context, tx *packagesRepo.Queries,
 }
 
 func (s *Service) startDeployment(ctx context.Context, logger *slog.Logger, projectID uuid.UUID, deploymentID uuid.UUID, dep *types.Deployment) (string, error) {
+	defer func() {
+		logger.InfoContext(ctx, "starting project-scoped functions reaper")
+		_, err := background.ExecuteProjectFunctionsReaperWorkflow(ctx, s.temporal, projectID)
+		if err != nil && !temporal.IsWorkflowExecutionAlreadyStartedError(err) {
+			logger.ErrorContext(
+				ctx, "failed to start project-scoped functions reaper workflow",
+				attr.SlogError(err),
+			)
+		}
+	}()
+
 	wr, err := background.ExecuteProcessDeploymentWorkflow(ctx, s.temporal, background.ProcessDeploymentWorkflowParams{
 		ProjectID:      projectID,
 		DeploymentID:   deploymentID,

server/internal/functions/deploy_fly.go

@@ -582,10 +582,18 @@ func (f *FlyRunner) reap(ctx context.Context, logger *slog.Logger, appsRepo *rep
 	}
 
 	reapErrorMessage := ""
-	if err := f.client.DeleteApp(ctx, app.AppName); err != nil {
-		// Log error but continue - we still want to mark it as reaped in the database
-		reapErrorMessage = err.Error()
-		logger.WarnContext(ctx, "delete app request failed", attr.SlogError(err))
+	if res.StatusCode >= 400 {
+		bodyBytes, readErr := io.ReadAll(res.Body)
+		if readErr == nil {
+			message := string(bodyBytes)
+			if len(message) > 500 {
+				message = message[:500]
+			}
+
+			reapErrorMessage = fmt.Sprintf("status %d: %s", res.StatusCode, message)
+		} else {
+			reapErrorMessage = fmt.Sprintf("status %d: failed to read response body: %v", res.StatusCode, readErr)
+		}
 	}
 
 	// Mark the app as reaped in the database