Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
33 changes: 25 additions & 8 deletions pkg/devcontainer/single.go
Original file line number Diff line number Diff line change
Expand Up @@ -427,17 +427,35 @@ 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,
buildInfo,
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)
}
}

Expand Down Expand Up @@ -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)
Expand Down
62 changes: 62 additions & 0 deletions pkg/devcontainer/single_delivery_test.go
Original file line number Diff line number Diff line change
@@ -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")
}
}
3 changes: 3 additions & 0 deletions pkg/driver/external/internal/testfixture/main.go
Original file line number Diff line number Diff line change
Expand Up @@ -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)
}
Expand Down
12 changes: 10 additions & 2 deletions pkg/driver/external/session.go
Original file line number Diff line number Diff line change
Expand Up @@ -46,15 +46,23 @@ 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{
sdkplugin.ProtocolVersion: sdkplugin.ClientPlugins(),
},
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 {
Expand Down
41 changes: 41 additions & 0 deletions pkg/driver/external/session_logging_test.go
Original file line number Diff line number Diff line change
@@ -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())
}
23 changes: 15 additions & 8 deletions pkg/tunnel/pipebridge.go
Original file line number Diff line number Diff line change
Expand Up @@ -2,6 +2,7 @@ package tunnel

import (
"context"
"errors"
"os"
"sync"
"time"
Expand Down Expand Up @@ -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
}
144 changes: 144 additions & 0 deletions pkg/tunnel/pipebridge_test.go
Original file line number Diff line number Diff line change
Expand Up @@ -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) {
Expand Down Expand Up @@ -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()

Expand Down
Loading