diff --git a/pkg/devcontainer/single.go b/pkg/devcontainer/single.go index 0deb36bc6a..4c256eae2d 100644 --- a/pkg/devcontainer/single.go +++ b/pkg/devcontainer/single.go @@ -427,6 +427,20 @@ func (r *runner) attemptPreStartDelivery( p *resolveParams, buildInfo *config.BuildInfo, ) { + strategy := r.newAgentDelivery() + switch strategy.Phase() { + case delivery.PhasePostStart: + log.Debug("agent delivery scheduled for post-start") + return + case delivery.PhasePreStart: + default: + log.Debugf( + "pre-start agent delivery skipped for unsupported phase %s", + strategy.Phase(), + ) + return + } + runOptions, err := r.buildRunOptionsForDelivery( mergedConfig, p.substitutionContext, @@ -434,10 +448,14 @@ func (r *runner) attemptPreStartDelivery( len(p.options.SecretsMount) > 0, ) if err != nil { + log.Debugf( + "pre-start agent delivery could not prepare run options; will use post-start: %v", + err, + ) return } - if preStartErr := r.deliverPreStart(ctx, runOptions); preStartErr != nil { - log.Debugf("pre-start delivery skipped or failed, will use post-start: %v", preStartErr) + if preStartErr := r.deliverPreStart(ctx, strategy, runOptions); preStartErr != nil { + log.Debugf("pre-start agent delivery failed; will use post-start: %v", preStartErr) } } @@ -729,12 +747,11 @@ func (r *runner) buildRunOptionsForDelivery( return r.getRunOptions(mergedConfig, substitutionContext, buildInfo, secretsMountRequired) } -func (r *runner) deliverPreStart(ctx context.Context, runOptions *driver.RunOptions) error { - strategy := r.newAgentDelivery() - if strategy.Phase() != delivery.PhasePreStart { - return fmt.Errorf("strategy phase is %s, not pre-start", strategy.Phase()) - } - +func (r *runner) deliverPreStart( + ctx context.Context, + strategy delivery.AgentDelivery, + runOptions *driver.RunOptions, +) error { binarySource, err := r.newBinarySource() if err != nil { return fmt.Errorf("create binary source: %w", err) diff --git a/pkg/devcontainer/single_delivery_test.go b/pkg/devcontainer/single_delivery_test.go new file mode 100644 index 0000000000..4bc63cf4f0 --- /dev/null +++ b/pkg/devcontainer/single_delivery_test.go @@ -0,0 +1,62 @@ +package devcontainer + +import ( + "context" + "errors" + "testing" + + "github.com/devsy-org/devsy/pkg/devcontainer/config" + "github.com/devsy-org/devsy/pkg/log" + "github.com/devsy-org/devsy/pkg/provider" + "go.uber.org/zap/zapcore" +) + +type failingArchitectureDriver struct { + mockDriver + err error +} + +func (d *failingArchitectureDriver) TargetArchitecture(context.Context, string) (string, error) { + return "", d.err +} + +func TestAttemptPreStartDeliveryLogsPlannedPostStartPhase(t *testing.T) { + logs := log.InitTestObserved(t, zapcore.DebugLevel) + r := newTestRunner(&mockDriver{}) + + // A nil configuration would fail if pre-start options were built. A + // post-start strategy should be recognized before reaching that work. + r.attemptPreStartDelivery(context.Background(), nil, nil, nil) + + if got := logs.FilterMessage("agent delivery scheduled for post-start").Len(); got != 1 { + t.Fatalf("planned post-start diagnostic count = %d, want 1", got) + } + if got := logs.FilterMessage("strategy phase is post-start, not pre-start").Len(); got != 0 { + t.Fatalf("phase-mismatch error diagnostic count = %d, want 0", got) + } +} + +func TestAttemptPreStartDeliveryLogsFailureAndContinues(t *testing.T) { + logs := log.InitTestObserved(t, zapcore.DebugLevel) + failure := errors.New("architecture unavailable") + r := newTestRunner(&failingArchitectureDriver{err: failure}) + r.workspaceConfig.Agent.Driver = provider.DockerDriver + + r.attemptPreStartDelivery( + context.Background(), + &config.MergedDevContainerConfig{}, + &resolveParams{substitutionContext: &config.SubstitutionContext{}}, + &config.BuildInfo{ImageMetadata: &config.ImageMetadataConfig{}}, + ) + + entries := logs.FilterMessage( + "pre-start agent delivery failed; will use post-start: " + + "resolve target architecture: architecture unavailable", + ).All() + if len(entries) != 1 { + t.Fatalf("pre-start delivery failure diagnostic count = %d, want 1", len(entries)) + } + if len(logs.FilterMessage("agent delivery scheduled for post-start").All()) != 0 { + t.Fatal("pre-start failure was misreported as a planned post-start strategy") + } +} diff --git a/pkg/driver/external/internal/testfixture/main.go b/pkg/driver/external/internal/testfixture/main.go index b4fe5ff18b..ca2036febf 100644 --- a/pkg/driver/external/internal/testfixture/main.go +++ b/pkg/driver/external/internal/testfixture/main.go @@ -44,6 +44,9 @@ func main() { } func serve(mode, state string, delay time.Duration, nonce string) { + if mode == "stream-startup-stderr" { + _, _ = fmt.Fprintln(os.Stderr, "runtime startup diagnostic "+os.Getenv("FIXTURE_TOKEN")) + } if mode == fake.CrashBeforeHandshake { os.Exit(22) } diff --git a/pkg/driver/external/session.go b/pkg/driver/external/session.go index ee3f7e54d2..05504dd5e5 100644 --- a/pkg/driver/external/session.go +++ b/pkg/driver/external/session.go @@ -46,6 +46,12 @@ func (h *Host) call( RuntimeBinary: binary, Args: h.config.External.Args, Env: append(slices.Clone(h.environment), h.config.External.Binary+"="+binary), }) + // Routine helper lifecycle diagnostics belong at trace; runtime stderr is + // preserved independently below, including unstructured backend failures. + frameworkLogLevel := hclog.Warn + if log.LevelString() == log.LevelTraceName { + frameworkLogLevel = hclog.Trace + } client := hplugin.NewClient(&hplugin.ClientConfig{ HandshakeConfig: sdkplugin.Handshake(), VersionedPlugins: map[int]hplugin.PluginSet{ @@ -53,8 +59,10 @@ func (h *Host) call( }, AllowedProtocols: []hplugin.Protocol{hplugin.ProtocolGRPC}, StartTimeout: h.timeout, - Logger: hclog.New(&hclog.LoggerOptions{Output: diagnostic, Level: hclog.Debug}), - Stderr: diagnostic, + Logger: hclog.New(&hclog.LoggerOptions{ + Output: diagnostic, Level: frameworkLogLevel, + }), + Stderr: diagnostic, RunnerFunc: func(logger hclog.Logger, command *exec.Cmd, socketDir string) (runner.Runner, error) { process, err := owned(logger, command, socketDir) if err != nil { diff --git a/pkg/driver/external/session_logging_test.go b/pkg/driver/external/session_logging_test.go new file mode 100644 index 0000000000..44ae63e908 --- /dev/null +++ b/pkg/driver/external/session_logging_test.go @@ -0,0 +1,41 @@ +package external + +import ( + "context" + + "github.com/devsy-org/devsy-runtime-sdk/conformance/fake" + "github.com/devsy-org/devsy/pkg/log" + "go.uber.org/zap/zapcore" +) + +func (s *HostSuite) TestDebugKeepsRuntimeDiagnosticsWithoutHelperShutdownNoise() { + s.T().Setenv("FIXTURE_TOKEN", "private-startup-canary") + observed := log.InitTestObserved(s.T(), zapcore.DebugLevel) + host := s.host("stream-startup-stderr") + s.NotEmpty(host.Info().RuntimeName) + + s.Positive(observed.FilterMessageSnippet("runtime startup diagnostic ***").Len()) + s.Positive(observed.FilterMessageSnippet("External runtime Info startup completed").Len()) + s.Zero(observed.FilterMessageSnippet("received EOF, stopping recv loop").Len()) + s.Zero(observed.FilterMessageSnippet("plugin process exited").Len()) + for _, entry := range observed.All() { + s.NotContains(entry.Message, "private-startup-canary") + } +} + +func (s *HostSuite) TestTraceKeepsHelperLifecycleDiagnostics() { + observed := log.InitTestObserved(s.T(), zapcore.DebugLevel-1) + host := s.host(fake.Normal) + s.NotEmpty(host.Info().RuntimeName) + + s.Positive(observed.FilterMessageSnippet("received EOF, stopping recv loop").Len()) + s.Positive(observed.FilterMessageSnippet("plugin process exited").Len()) +} + +func (s *HostSuite) TestDebugKeepsUnexpectedHelperExitDiagnostics() { + observed := log.InitTestObserved(s.T(), zapcore.DebugLevel) + _, err := s.newHost(context.Background(), fake.CrashBeforeHandshake, startupTimeout) + s.Require().Error(err) + s.Positive(observed.FilterMessageSnippet("plugin process exited").Len()) + s.Positive(observed.FilterMessageSnippet("exit status 22").Len()) +} diff --git a/pkg/tunnel/pipebridge.go b/pkg/tunnel/pipebridge.go index dff7df33fd..3d8acfdcb8 100644 --- a/pkg/tunnel/pipebridge.go +++ b/pkg/tunnel/pipebridge.go @@ -2,6 +2,7 @@ package tunnel import ( "context" + "errors" "os" "sync" "time" @@ -102,12 +103,18 @@ func (pb *PipeBridge) RunPair( // Run the two sides concurrently and wait for both to finish (or the slower // side to be abandoned after joinTimeout). tunnelErr, handlerErr := iojoin.Join(tunnelSide, handlerSide, joinTimeout, stop) - log.Debugf( - "pipe bridge completed: tunnel_err=%v handler_err=%v parent_err=%v pair_err=%v", - tunnelErr, - handlerErr, - ctx.Err(), - pairCtx.Err(), - ) - return ClassifyTunnelErrors(tunnelErr, handlerErr) + classifiedErr := ClassifyTunnelErrors(tunnelErr, handlerErr) + internalTunnelCancel := errors.Is(tunnelErr, context.Canceled) && ctx.Err() == nil + if classifiedErr == nil && ctx.Err() == nil && (tunnelErr == nil || internalTunnelCancel) { + log.Debug("pipe bridge completed successfully") + } else { + log.Debugf( + "pipe bridge completed: tunnel_err=%v handler_err=%v parent_err=%v pair_err=%v", + tunnelErr, + handlerErr, + ctx.Err(), + pairCtx.Err(), + ) + } + return classifiedErr } diff --git a/pkg/tunnel/pipebridge_test.go b/pkg/tunnel/pipebridge_test.go index f1366ff2ad..e46e8ba948 100644 --- a/pkg/tunnel/pipebridge_test.go +++ b/pkg/tunnel/pipebridge_test.go @@ -9,7 +9,10 @@ import ( "testing" "time" + "github.com/devsy-org/devsy/pkg/log" "github.com/devsy-org/devsy/pkg/util/goleaktest" + "go.uber.org/zap/zapcore" + "go.uber.org/zap/zaptest/observer" ) func TestMain(m *testing.M) { @@ -184,6 +187,147 @@ func TestRunPairContextCancellation(t *testing.T) { } } +func TestRunPairLogsSuccessfulCompletionWithoutCancellationNoise(t *testing.T) { + logs := capturePipeBridgeLogs(t) + pb, err := NewPipeBridge() + if err != nil { + t.Fatalf("NewPipeBridge() error = %v", err) + } + defer pb.Close() + + if err := pb.RunPair( + context.Background(), + func(ctx context.Context, _ *os.File, _ *os.File) error { + <-ctx.Done() + return ctx.Err() + }, + func(context.Context, *os.File, *os.File) error { return nil }, + ); err != nil { + t.Fatalf("RunPair() error = %v, want nil", err) + } + + entries := logs.All() + if len(entries) != 1 || entries[0].Message != "pipe bridge completed successfully" { + t.Fatalf("successful completion logs = %+v, want one plain success message", entries) + } +} + +func TestRunPairLogsUnclassifiedTunnelFailureDetails(t *testing.T) { + logs := capturePipeBridgeLogs(t) + pb, err := NewPipeBridge() + if err != nil { + t.Fatalf("NewPipeBridge() error = %v", err) + } + defer pb.Close() + + tunnelErr := errors.New("tunnel failed after handler completion") + err = pb.RunPair( + context.Background(), + func(ctx context.Context, _ *os.File, _ *os.File) error { + <-ctx.Done() + return tunnelErr + }, + func(context.Context, *os.File, *os.File) error { return nil }, + ) + if err != nil { + t.Fatalf("RunPair() error = %v, want unchanged nil classification", err) + } + + entries := logs.FilterMessageSnippet("tunnel_err=tunnel failed after handler completion") + if entries.Len() != 1 { + t.Fatalf("unclassified tunnel failure logs = %+v, want tunnel error details", logs.All()) + } +} + +func TestRunPairLogsHandlerFailureDetails(t *testing.T) { + logs := capturePipeBridgeLogs(t) + pb, err := NewPipeBridge() + if err != nil { + t.Fatalf("NewPipeBridge() error = %v", err) + } + defer pb.Close() + + handlerErr := errors.New("handler failed") + err = pb.RunPair( + context.Background(), + func(ctx context.Context, _ *os.File, _ *os.File) error { + <-ctx.Done() + return ctx.Err() + }, + func(context.Context, *os.File, *os.File) error { return handlerErr }, + ) + if !errors.Is(err, handlerErr) { + t.Fatalf("RunPair() error = %v, want wrapped handler failure", err) + } + + entries := logs.FilterMessageSnippet("handler_err=handler failed") + if entries.Len() != 1 { + t.Fatalf("handler failure logs = %+v, want handler error details", logs.All()) + } +} + +func TestRunPairLogsTunnelFailureDetails(t *testing.T) { + logs := capturePipeBridgeLogs(t) + pb, err := NewPipeBridge() + if err != nil { + t.Fatalf("NewPipeBridge() error = %v", err) + } + defer pb.Close() + + tunnelErr := errors.New("dial failed") + err = pb.RunPair( + context.Background(), + func(context.Context, *os.File, *os.File) error { return tunnelErr }, + func(_ context.Context, stdout *os.File, _ *os.File) error { + _, err := stdout.Read(make([]byte, 1)) + return err + }, + ) + if !errors.Is(err, tunnelErr) { + t.Fatalf("RunPair() error = %v, want wrapped tunnel failure", err) + } + + entries := logs.FilterMessageSnippet("tunnel_err=dial failed") + if entries.Len() != 1 { + t.Fatalf("tunnel failure logs = %+v, want tunnel error details", logs.All()) + } +} + +func TestRunPairLogsParentCancellationDetails(t *testing.T) { + logs := capturePipeBridgeLogs(t) + pb, err := NewPipeBridge() + if err != nil { + t.Fatalf("NewPipeBridge() error = %v", err) + } + defer pb.Close() + + ctx, cancel := context.WithCancel(context.Background()) + err = pb.RunPair( + ctx, + func(ctx context.Context, _ *os.File, _ *os.File) error { + <-ctx.Done() + return ctx.Err() + }, + func(context.Context, *os.File, *os.File) error { + cancel() + return nil + }, + ) + if err != nil { + t.Fatalf("RunPair() error = %v, want nil for classified shutdown", err) + } + + entries := logs.FilterMessageSnippet("parent_err=context canceled") + if entries.Len() != 1 { + t.Fatalf("parent cancellation logs = %+v, want cancellation details", logs.All()) + } +} + +func capturePipeBridgeLogs(t *testing.T) *observer.ObservedLogs { + t.Helper() + return log.InitTestObserved(t, zapcore.DebugLevel) +} + func TestRunPairPipesClosedAfterReturn(t *testing.T) { t.Parallel()