Nov 8, 2022 · Nov 7, 2022 · Nov 8, 2022 · Nov 8, 2022 · Nov 8, 2022 · Nov 8, 2022
diff --git a/agent/agent_test.go b/agent/agent_test.go

 t.Run("SSH", func(t *testing.T) {
 t.Parallel()
 ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitLong)
 defer cancel()

 conn, stats := setupAgent(t, codersdk.WorkspaceAgentMetadata{}, 0)

 sshClient, err := conn.SSHClient()
 sshClient, err := conn.SSHClient(ctx)
 require.NoError(t, err)
 defer sshClient.Close()
 session, err := sshClient.NewSession()
 t.Run("ReconnectingPTY", func(t *testing.T) {
 t.Parallel()

 ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitLong)
 defer cancel()

 conn, stats := setupAgent(t, codersdk.WorkspaceAgentMetadata{}, 0)

 ptyConn, err := conn.ReconnectingPTY(uuid.NewString(), 128, 128, "/bin/bash")
 ptyConn, err := conn.ReconnectingPTY(ctx,uuid.NewString(), 128, 128, "/bin/bash")
 require.NoError(t, err)
 defer ptyConn.Close()


 t.Run("SFTP", func(t *testing.T) {
 t.Parallel()
 ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitLong)
 defer cancel()
 u, err := user.Current()
 require.NoError(t, err, "get current user")
 home := u.HomeDir
 if runtime.GOOS == "windows" {
 home = "/" + strings.ReplaceAll(home, "\\", "/")
 }
 conn, _ := setupAgent(t, codersdk.WorkspaceAgentMetadata{}, 0)
 sshClient, err := conn.SSHClient()
 sshClient, err := conn.SSHClient(ctx)
 require.NoError(t, err)
 defer sshClient.Close()
 client, err := sftp.NewClient(sshClient)
 t.Run("SCP", func(t *testing.T) {
 t.Parallel()

 ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitLong)
 defer cancel()

 conn, _ := setupAgent(t, codersdk.WorkspaceAgentMetadata{}, 0)
 sshClient, err := conn.SSHClient()
 sshClient, err := conn.SSHClient(ctx)
 require.NoError(t, err)
 defer sshClient.Close()
 scpClient, err := scp.NewClientBySSH(sshClient)
 t.Skip("ConPTY appears to be inconsistent on Windows.")
 }

 ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitLong)
 defer cancel()

 conn, _ := setupAgent(t, codersdk.WorkspaceAgentMetadata{}, 0)
 id := uuid.NewString()
 netConn, err := conn.ReconnectingPTY(id, 100, 100, "/bin/bash")
 netConn, err := conn.ReconnectingPTY(ctx,id, 100, 100, "/bin/bash")
 require.NoError(t, err)
 bufRead := bufio.NewReader(netConn)

 expectLine(matchEchoOutput)

 _ = netConn.Close()
 netConn, err = conn.ReconnectingPTY(id, 100, 100, "/bin/bash")
 netConn, err = conn.ReconnectingPTY(ctx,id, 100, 100, "/bin/bash")
 require.NoError(t, err)
 bufRead = bufio.NewReader(netConn)

 t.Run("Speedtest", func(t *testing.T) {
 t.Parallel()
 t.Skip("This test is relatively flakey because of Tailscale's speedtest code...")
 ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitLong)
 defer cancel()
 derpMap := tailnettest.RunDERPAndSTUN(t)
 conn, _ := setupAgent(t, codersdk.WorkspaceAgentMetadata{
 DERPMap: derpMap,
 }, 0)
 defer conn.Close()
 res, err := conn.Speedtest(speedtest.Upload, 250*time.Millisecond)
 res, err := conn.Speedtest(ctx,speedtest.Upload, 250*time.Millisecond)
 require.NoError(t, err)
 t.Logf("%.2f MBits/s", res[len(res)-1].MBitsPerSecond())
 })
 if err != nil {
 return
 }
 ssh, err := agentConn.SSH()

 ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitLong)
 ssh, err := agentConn.SSH(ctx)
 cancel()
 if err != nil {
 _ = conn.Close()
 return
 }

 func setupSSHSession(t *testing.T, options codersdk.WorkspaceAgentMetadata) *ssh.Session {
 ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitLong)
 defer cancel()
 conn, _ := setupAgent(t, options, 0)
 sshClient, err := conn.SSHClient()
 sshClient, err := conn.SSHClient(ctx)
 require.NoError(t, err)
 t.Cleanup(func() {
 _ = sshClient.Close()
diff --git a/cli/agent_test.go b/cli/agent_test.go
 return err == nil
 }, testutil.WaitMedium, testutil.IntervalFast)

 sshClient, err := dialer.SSHClient()
 sshClient, err := dialer.SSHClient(ctx)
 require.NoError(t, err)
 defer sshClient.Close()
 session, err := sshClient.NewSession()
diff --git a/cli/configssh_test.go b/cli/configssh_test.go
 "github.com/coder/coder/provisioner/echo"
 "github.com/coder/coder/provisionersdk/proto"
 "github.com/coder/coder/pty/ptytest"
 "github.com/coder/coder/testutil"
 )

 func sshConfigFileName(t *testing.T) (sshConfig string) {
 if err != nil {
 break
 }
 ssh, err := agentConn.SSH()
 ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitLong)
 ssh, err := agentConn.SSH(ctx)
 cancel()
 assert.NoError(t, err)
 wg.Add(2)
 go func() {
diff --git a/cli/loadtest.go b/cli/loadtest.go
 "os"
 "strconv"
 "strings"
 "sync"
 "time"

 "github.com/spf13/cobra"
 "go.opentelemetry.io/otel/trace"
 "golang.org/x/xerrors"

 "github.com/coder/coder/cli/cliflag"
 "github.com/coder/coder/coderd/tracing"
 "github.com/coder/coder/codersdk"
 "github.com/coder/coder/loadtest/harness"
 )

 const loadtestTracerName = "coder_loadtest"

 func loadtest() *cobra.Command {
 var (
 configPath  string
 outputSpecs []string

 traceEnable          bool
 traceCoder           bool
 traceHoneycombAPIKey string
 tracePropagate       bool
 )
 cmd := &cobra.Command{
 Use:   "loadtest --config <path> [--output json[:path]] [--output text[:path]]]",
 Hidden: true,
 Args:   cobra.ExactArgs(0),
 RunE: func(cmd *cobra.Command, args []string) error {
 ctx := tracing.SetTracerName(cmd.Context(), loadtestTracerName)

 config, err := loadLoadTestConfigFile(configPath, cmd.InOrStdin())
 if err != nil {
 return err
 return err
 }

 me, err := client.User(cmd.Context(), codersdk.Me)
 me, err := client.User(ctx, codersdk.Me)
 if err != nil {
 return xerrors.Errorf("fetch current user: %w", err)
 }
 }
 }
 if !ok {
 return xerrors.Errorf("Not logged in as site owner. Load testing is only available to site owners.")
 return xerrors.Errorf("Not logged in as a site owner. Load testing is only available to site owners.")
 }

 // Setup tracing and start a span.
 var (
 shouldTrace                           = traceEnable || traceCoder || traceHoneycombAPIKey != ""
 tracerProvider   trace.TracerProvider = trace.NewNoopTracerProvider()
 closeTracingOnce sync.Once
 closeTracing     = func(_ context.Context) error {
 return nil
 }
 )
 if shouldTrace {
 tracerProvider, closeTracing, err = tracing.TracerProvider(ctx, loadtestTracerName, tracing.TracerOpts{
 Default:   traceEnable,
 Coder:     traceCoder,
 Honeycomb: traceHoneycombAPIKey,
 })
 if err != nil {
 return xerrors.Errorf("initialize tracing: %w", err)
 }
 defer func() {
 closeTracingOnce.Do(func() {
 // Allow time for traces to flush even if command
 // context is canceled.
 ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 defer cancel()
 _ = closeTracing(ctx)
 })
 }()
 }
 tracer := tracerProvider.Tracer(loadtestTracerName)

 // Disable ratelimits for future requests.
 // Disable ratelimits and propagate tracing spans for future
 // requests. Individual tests will setup their own loggers.
 client.BypassRatelimits = true
 client.PropagateTracing = tracePropagate

 // Prepare the test.
 strategy := config.Strategy.ExecutionStrategy()

 for j := 0; j < t.Count; j++ {
 id := strconv.Itoa(j)
 runner, err := t.NewRunner(client)
 runner, err := t.NewRunner(client.Clone())
 if err != nil {
 return xerrors.Errorf("create %q runner for %s/%s: %w", t.Type, name, id, err)
 }

 th.AddRun(name, id, runner)
 th.AddRun(name, id, &runnableTraceWrapper{
 tracer:   tracer,
 spanName: fmt.Sprintf("%s/%s", name, id),
 runner:   runner,
 })
 }
 }

 _, _ = fmt.Fprintln(cmd.ErrOrStderr(), "Running load test...")

 testCtx :=cmd.Context()
 testCtx :=ctx
 if config.Timeout > 0 {
 var cancel func()
 testCtx, cancel = context.WithTimeout(testCtx, time.Duration(config.Timeout))

 // Cleanup.
 _, _ = fmt.Fprintln(cmd.ErrOrStderr(), "\nCleaning up...")
 err = th.Cleanup(cmd.Context())
 err = th.Cleanup(ctx)
 if err != nil {
 return xerrors.Errorf("cleanup tests: %w", err)
 }

 // Upload traces.
 if shouldTrace {
 _, _ = fmt.Fprintln(cmd.ErrOrStderr(), "\nUploading traces...")
 closeTracingOnce.Do(func() {
 ctx, cancel := context.WithTimeout(ctx, 1*time.Minute)
 defer cancel()
 err := closeTracing(ctx)
 if err != nil {
 _, _ = fmt.Fprintf(cmd.ErrOrStderr(), "\nError uploading traces: %+v\n", err)
 }
 })
 }

 if res.TotalFail > 0 {
 return xerrors.New("load test failed, see above for more details")
 }

 cliflag.StringVarP(cmd.Flags(), &configPath, "config", "", "CODER_LOADTEST_CONFIG_PATH", "", "Path to the load test configuration file, or - to read from stdin.")
 cliflag.StringArrayVarP(cmd.Flags(), &outputSpecs, "output", "", "CODER_LOADTEST_OUTPUTS", []string{"text"}, "Output formats, see usage for more information.")

 cliflag.BoolVarP(cmd.Flags(), &traceEnable, "trace", "", "CODER_LOADTEST_TRACE", false, "Whether application tracing data is collected. It exports to a backend configured by environment variables. See: https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/protocol/exporter.md")
 cliflag.BoolVarP(cmd.Flags(), &traceCoder, "trace-coder", "", "CODER_LOADTEST_TRACE_CODER", false, "Whether opentelemetry traces are sent to Coder. We recommend keeping this disabled unless we advise you to enable it.")
 cliflag.StringVarP(cmd.Flags(), &traceHoneycombAPIKey, "trace-honeycomb-api-key", "", "CODER_LOADTEST_TRACE_HONEYCOMB_API_KEY", "", "Enables trace exporting to Honeycomb.io using the provided API key.")
 cliflag.BoolVarP(cmd.Flags(), &tracePropagate, "trace-propagate", "", "CODER_LOADTEST_TRACE_PROPAGATE", false, "Enables trace propagation to the Coder backend, which will be used to correlate server-side spans with client-side spans. Only enable this if the server is configured with the exact same tracing configuration as the client.")

 return cmd
 }


 return out, nil
 }

 type runnableTraceWrapper struct {
 tracer   trace.Tracer
 spanName string
 runner   harness.Runnable

 span trace.Span
 }

 var _ harness.Runnable = &runnableTraceWrapper{}
 var _ harness.Cleanable = &runnableTraceWrapper{}

 func (r *runnableTraceWrapper) Run(ctx context.Context, id string, logs io.Writer) error {
 ctx, span := r.tracer.Start(ctx, r.spanName, trace.WithNewRoot())
 defer span.End()
 r.span = span

 traceID := "unknown trace ID"
 spanID := "unknown span ID"
 if span.SpanContext().HasTraceID() {
 traceID = span.SpanContext().TraceID().String()
 }
 if span.SpanContext().HasSpanID() {
 spanID = span.SpanContext().SpanID().String()
 }
 _, _ = fmt.Fprintf(logs, "Trace ID: %s\n", traceID)
 _, _ = fmt.Fprintf(logs, "Span ID: %s\n\n", spanID)

 // Make a separate span for the run itself so the sub-spans are grouped
 // neatly. The cleanup span is also a child of the above span so this is
 // important for readability.
 ctx2, span2 := r.tracer.Start(ctx, r.spanName+" run")
 defer span2.End()
 return r.runner.Run(ctx2, id, logs)
 }

 func (r *runnableTraceWrapper) Cleanup(ctx context.Context, id string) error {
 c, ok := r.runner.(harness.Cleanable)
 if !ok {
 return nil
 }

 if r.span != nil {
 ctx = trace.ContextWithSpanContext(ctx, r.span.SpanContext())
 }
 ctx, span := r.tracer.Start(ctx, r.spanName+" cleanup")
 defer span.End()

 return c.Cleanup(ctx, id)
 }
diff --git a/cli/loadtest_test.go b/cli/loadtest_test.go
 require.NoError(t, err, msg)
 }

 t.Logf("output %d:\n\n%s", i, string(b))

 switch output.format {
 case "text":
 require.Contains(t, string(b), "Test results:", msg)
diff --git a/cli/server.go b/cli/server.go

 if cfg.Trace.Enable.Value || shouldCoderTrace {
 sdkTracerProvider, closeTracing, err := tracing.TracerProvider(ctx, "coderd", tracing.TracerOpts{
 Default: cfg.Trace.Enable.Value,
 Coder:   shouldCoderTrace,
 Default:   cfg.Trace.Enable.Value,
 Coder:     shouldCoderTrace,
 Honeycomb: cfg.Trace.HoneycombAPIKey.Value,
 })
 if err != nil {
 logger.Warn(ctx, "start telemetry exporter", slog.Error(err))
diff --git a/cli/speedtest.go b/cli/speedtest.go
 dir = tsspeedtest.Upload
 }
 cmd.Printf("Starting a %ds %s test...\n", int(duration.Seconds()), dir)
 results, err := conn.Speedtest(dir, duration)
 results, err := conn.Speedtest(ctx,dir, duration)
 if err != nil {
 return err
 }
Original file line number	Diff line number	Diff line change
Expand Up		@@ -58,9 +58,12 @@ func TestAgent(t *testing.T) {

		t.Run("SSH", func(t *testing.T) {
		t.Parallel()
		ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitLong)
		defer cancel()

		conn, stats := setupAgent(t, codersdk.WorkspaceAgentMetadata{}, 0)

		sshClient, err := conn.SSHClient()
		sshClient, err := conn.SSHClient(ctx)
		require.NoError(t, err)
		defer sshClient.Close()
		session, err := sshClient.NewSession()
Expand All		@@ -75,9 +78,12 @@ func TestAgent(t *testing.T) {
		t.Run("ReconnectingPTY", func(t *testing.T) {
		t.Parallel()

		ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitLong)
		defer cancel()

		conn, stats := setupAgent(t, codersdk.WorkspaceAgentMetadata{}, 0)

		ptyConn, err := conn.ReconnectingPTY(uuid.NewString(), 128, 128, "/bin/bash")
		ptyConn, err := conn.ReconnectingPTY(ctx,uuid.NewString(), 128, 128, "/bin/bash")
		require.NoError(t, err)
		defer ptyConn.Close()

Expand DownExpand Up		@@ -217,14 +223,16 @@ func TestAgent(t *testing.T) {

		t.Run("SFTP", func(t *testing.T) {
		t.Parallel()
		ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitLong)
		defer cancel()
		u, err := user.Current()
		require.NoError(t, err, "get current user")
		home := u.HomeDir
		if runtime.GOOS == "windows" {
		home = "/" + strings.ReplaceAll(home, "\\", "/")
		}
		conn, _ := setupAgent(t, codersdk.WorkspaceAgentMetadata{}, 0)
		sshClient, err := conn.SSHClient()
		sshClient, err := conn.SSHClient(ctx)
		require.NoError(t, err)
		defer sshClient.Close()
		client, err := sftp.NewClient(sshClient)
Expand All		@@ -250,8 +258,11 @@ func TestAgent(t *testing.T) {
		t.Run("SCP", func(t *testing.T) {
		t.Parallel()

		ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitLong)
		defer cancel()

		conn, _ := setupAgent(t, codersdk.WorkspaceAgentMetadata{}, 0)
		sshClient, err := conn.SSHClient()
		sshClient, err := conn.SSHClient(ctx)
		require.NoError(t, err)
		defer sshClient.Close()
		scpClient, err := scp.NewClientBySSH(sshClient)
Expand DownExpand Up		@@ -386,9 +397,12 @@ func TestAgent(t *testing.T) {
		t.Skip("ConPTY appears to be inconsistent on Windows.")
		}

		ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitLong)
		defer cancel()

		conn, _ := setupAgent(t, codersdk.WorkspaceAgentMetadata{}, 0)
		id := uuid.NewString()
		netConn, err := conn.ReconnectingPTY(id, 100, 100, "/bin/bash")
		netConn, err := conn.ReconnectingPTY(ctx,id, 100, 100, "/bin/bash")
		require.NoError(t, err)
		bufRead := bufio.NewReader(netConn)

Expand DownExpand Up		@@ -426,7 +440,7 @@ func TestAgent(t *testing.T) {
		expectLine(matchEchoOutput)

		_ = netConn.Close()
		netConn, err = conn.ReconnectingPTY(id, 100, 100, "/bin/bash")
		netConn, err = conn.ReconnectingPTY(ctx,id, 100, 100, "/bin/bash")
		require.NoError(t, err)
		bufRead = bufio.NewReader(netConn)

Expand DownExpand Up		@@ -504,12 +518,14 @@ func TestAgent(t *testing.T) {
		t.Run("Speedtest", func(t *testing.T) {
		t.Parallel()
		t.Skip("This test is relatively flakey because of Tailscale's speedtest code...")
		ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitLong)
		defer cancel()
		derpMap := tailnettest.RunDERPAndSTUN(t)
		conn, _ := setupAgent(t, codersdk.WorkspaceAgentMetadata{
		DERPMap: derpMap,
		}, 0)
		defer conn.Close()
		res, err := conn.Speedtest(speedtest.Upload, 250*time.Millisecond)
		res, err := conn.Speedtest(ctx,speedtest.Upload, 250*time.Millisecond)
		require.NoError(t, err)
		t.Logf("%.2f MBits/s", res[len(res)-1].MBitsPerSecond())
		})
Expand DownExpand Up		@@ -599,7 +615,10 @@ func setupSSHCommand(t testing.T, beforeArgs []string, afterArgs []string) exe
		if err != nil {
		return
		}
		ssh, err := agentConn.SSH()

		ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitLong)
		ssh, err := agentConn.SSH(ctx)
		cancel()
		if err != nil {
		_ = conn.Close()
		return
Expand All		@@ -626,8 +645,10 @@ func setupSSHCommand(t testing.T, beforeArgs []string, afterArgs []string) exe
		}

		func setupSSHSession(t testing.T, options codersdk.WorkspaceAgentMetadata) ssh.Session {
		ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitLong)
		defer cancel()
		conn, _ := setupAgent(t, options, 0)
		sshClient, err := conn.SSHClient()
		sshClient, err := conn.SSHClient(ctx)
		require.NoError(t, err)
		t.Cleanup(func() {
		_ = sshClient.Close()
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -198,7 +198,7 @@ func TestWorkspaceAgent(t *testing.T) {
		return err == nil
		}, testutil.WaitMedium, testutil.IntervalFast)

		sshClient, err := dialer.SSHClient()
		sshClient, err := dialer.SSHClient(ctx)
		require.NoError(t, err)
		defer sshClient.Close()
		session, err := sshClient.NewSession()
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -28,6 +28,7 @@ import (
		"github.com/coder/coder/provisioner/echo"
		"github.com/coder/coder/provisionersdk/proto"
		"github.com/coder/coder/pty/ptytest"
		"github.com/coder/coder/testutil"
		)

		func sshConfigFileName(t *testing.T) (sshConfig string) {
Expand DownExpand Up		@@ -131,7 +132,9 @@ func TestConfigSSH(t *testing.T) {
		if err != nil {
		break
		}
		ssh, err := agentConn.SSH()
		ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitLong)
		ssh, err := agentConn.SSH(ctx)
		cancel()
		assert.NoError(t, err)
		wg.Add(2)
		go func() {
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -8,20 +8,30 @@ import (
		"os"
		"strconv"
		"strings"
		"sync"
		"time"

		"github.com/spf13/cobra"
		"go.opentelemetry.io/otel/trace"
		"golang.org/x/xerrors"

		"github.com/coder/coder/cli/cliflag"
		"github.com/coder/coder/coderd/tracing"
		"github.com/coder/coder/codersdk"
		"github.com/coder/coder/loadtest/harness"
		)

		const loadtestTracerName = "coder_loadtest"

		func loadtest() *cobra.Command {
		var (
		configPath string
		outputSpecs []string

		traceEnable bool
		traceCoder bool
		traceHoneycombAPIKey string
		tracePropagate bool
		)
		cmd := &cobra.Command{
		Use: "loadtest --config <path> [--output json[:path]] [--output text[:path]]]",
Expand DownExpand Up		@@ -53,6 +63,8 @@ func loadtest() *cobra.Command {
		Hidden: true,
		Args: cobra.ExactArgs(0),
		RunE: func(cmd *cobra.Command, args []string) error {
		ctx := tracing.SetTracerName(cmd.Context(), loadtestTracerName)

		config, err := loadLoadTestConfigFile(configPath, cmd.InOrStdin())
		if err != nil {
		return err
Expand All		@@ -67,7 +79,7 @@ func loadtest() *cobra.Command {
		return err
		}

		me, err := client.User(cmd.Context(), codersdk.Me)
		me, err := client.User(ctx, codersdk.Me)
		if err != nil {
		return xerrors.Errorf("fetch current user: %w", err)
		}
Expand All		@@ -84,11 +96,43 @@ func loadtest() *cobra.Command {
		}
		}
		if !ok {
		return xerrors.Errorf("Not logged in as site owner. Load testing is only available to site owners.")
		return xerrors.Errorf("Not logged in as a site owner. Load testing is only available to site owners.")
		}

		// Setup tracing and start a span.
		var (
		shouldTrace = traceEnable \|\| traceCoder \|\| traceHoneycombAPIKey != ""
		tracerProvider trace.TracerProvider = trace.NewNoopTracerProvider()
		closeTracingOnce sync.Once
		closeTracing = func(_ context.Context) error {
		return nil
		}
		)
		if shouldTrace {
		tracerProvider, closeTracing, err = tracing.TracerProvider(ctx, loadtestTracerName, tracing.TracerOpts{
		Default: traceEnable,
		Coder: traceCoder,
		Honeycomb: traceHoneycombAPIKey,
		})
		if err != nil {
		return xerrors.Errorf("initialize tracing: %w", err)
		}
		defer func() {
		closeTracingOnce.Do(func() {
		// Allow time for traces to flush even if command
		// context is canceled.
		ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
		defer cancel()
		_ = closeTracing(ctx)
		})
		}()
		}
		tracer := tracerProvider.Tracer(loadtestTracerName)

		// Disable ratelimits for future requests.
		// Disable ratelimits and propagate tracing spans for future
		// requests. Individual tests will setup their own loggers.
		client.BypassRatelimits = true
		client.PropagateTracing = tracePropagate

		// Prepare the test.
		strategy := config.Strategy.ExecutionStrategy()
Expand All		@@ -99,18 +143,22 @@ func loadtest() *cobra.Command {

		for j := 0; j < t.Count; j++ {
		id := strconv.Itoa(j)
		runner, err := t.NewRunner(client)
		runner, err := t.NewRunner(client.Clone())
		if err != nil {
		return xerrors.Errorf("create %q runner for %s/%s: %w", t.Type, name, id, err)
		}

		th.AddRun(name, id, runner)
		th.AddRun(name, id, &runnableTraceWrapper{
		tracer: tracer,
		spanName: fmt.Sprintf("%s/%s", name, id),
		runner: runner,
		})
		}
		}

		_, _ = fmt.Fprintln(cmd.ErrOrStderr(), "Running load test...")

		testCtx :=cmd.Context()
		testCtx :=ctx
		if config.Timeout > 0 {
		var cancel func()
		testCtx, cancel = context.WithTimeout(testCtx, time.Duration(config.Timeout))
Expand DownExpand Up		@@ -158,11 +206,24 @@ func loadtest() *cobra.Command {

		// Cleanup.
		_, _ = fmt.Fprintln(cmd.ErrOrStderr(), "\nCleaning up...")
		err = th.Cleanup(cmd.Context())
		err = th.Cleanup(ctx)
		if err != nil {
		return xerrors.Errorf("cleanup tests: %w", err)
		}

		// Upload traces.
		if shouldTrace {
		_, _ = fmt.Fprintln(cmd.ErrOrStderr(), "\nUploading traces...")
		closeTracingOnce.Do(func() {
		ctx, cancel := context.WithTimeout(ctx, 1*time.Minute)
		defer cancel()
		err := closeTracing(ctx)
		if err != nil {
		_, _ = fmt.Fprintf(cmd.ErrOrStderr(), "\nError uploading traces: %+v\n", err)
		}
		})
		}

		if res.TotalFail > 0 {
		return xerrors.New("load test failed, see above for more details")
		}
Expand All		@@ -173,6 +234,12 @@ func loadtest() *cobra.Command {

		cliflag.StringVarP(cmd.Flags(), &configPath, "config", "", "CODER_LOADTEST_CONFIG_PATH", "", "Path to the load test configuration file, or - to read from stdin.")
		cliflag.StringArrayVarP(cmd.Flags(), &outputSpecs, "output", "", "CODER_LOADTEST_OUTPUTS", []string{"text"}, "Output formats, see usage for more information.")

		cliflag.BoolVarP(cmd.Flags(), &traceEnable, "trace", "", "CODER_LOADTEST_TRACE", false, "Whether application tracing data is collected. It exports to a backend configured by environment variables. See: https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/protocol/exporter.md")
		cliflag.BoolVarP(cmd.Flags(), &traceCoder, "trace-coder", "", "CODER_LOADTEST_TRACE_CODER", false, "Whether opentelemetry traces are sent to Coder. We recommend keeping this disabled unless we advise you to enable it.")
		cliflag.StringVarP(cmd.Flags(), &traceHoneycombAPIKey, "trace-honeycomb-api-key", "", "CODER_LOADTEST_TRACE_HONEYCOMB_API_KEY", "", "Enables trace exporting to Honeycomb.io using the provided API key.")
		cliflag.BoolVarP(cmd.Flags(), &tracePropagate, "trace-propagate", "", "CODER_LOADTEST_TRACE_PROPAGATE", false, "Enables trace propagation to the Coder backend, which will be used to correlate server-side spans with client-side spans. Only enable this if the server is configured with the exact same tracing configuration as the client.")

		return cmd
		}

Expand DownExpand Up		@@ -271,3 +338,53 @@ func parseLoadTestOutputs(outputs []string) ([]loadTestOutput, error) {

		return out, nil
		}

		type runnableTraceWrapper struct {
		tracer trace.Tracer
		spanName string
		runner harness.Runnable

		span trace.Span
		}

		var _ harness.Runnable = &runnableTraceWrapper{}
		var _ harness.Cleanable = &runnableTraceWrapper{}

		func (r *runnableTraceWrapper) Run(ctx context.Context, id string, logs io.Writer) error {
		ctx, span := r.tracer.Start(ctx, r.spanName, trace.WithNewRoot())
		defer span.End()
		r.span = span

		traceID := "unknown trace ID"
		spanID := "unknown span ID"
		if span.SpanContext().HasTraceID() {
		traceID = span.SpanContext().TraceID().String()
		}
		if span.SpanContext().HasSpanID() {
		spanID = span.SpanContext().SpanID().String()
		}
		_, _ = fmt.Fprintf(logs, "Trace ID: %s\n", traceID)
		_, _ = fmt.Fprintf(logs, "Span ID: %s\n\n", spanID)

		// Make a separate span for the run itself so the sub-spans are grouped
		// neatly. The cleanup span is also a child of the above span so this is
		// important for readability.
		ctx2, span2 := r.tracer.Start(ctx, r.spanName+" run")
		defer span2.End()
		return r.runner.Run(ctx2, id, logs)
		}

		func (r *runnableTraceWrapper) Cleanup(ctx context.Context, id string) error {
		c, ok := r.runner.(harness.Cleanable)
		if !ok {
		return nil
		}

		if r.span != nil {
		ctx = trace.ContextWithSpanContext(ctx, r.span.SpanContext())
		}
		ctx, span := r.tracer.Start(ctx, r.spanName+" cleanup")
		defer span.End()

		return c.Cleanup(ctx, id)
		}
Original file line number	Diff line number	Diff line change
Expand Up		@@ -276,6 +276,8 @@ func TestLoadTest(t *testing.T) {
		require.NoError(t, err, msg)
		}

		t.Logf("output %d:\n\n%s", i, string(b))

		switch output.format {
		case "text":
		require.Contains(t, string(b), "Test results:", msg)
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -128,8 +128,9 @@ func Server(vip viper.Viper, newAPI func(context.Context, coderd.Options) (*co

		if cfg.Trace.Enable.Value \|\| shouldCoderTrace {
		sdkTracerProvider, closeTracing, err := tracing.TracerProvider(ctx, "coderd", tracing.TracerOpts{
		Default: cfg.Trace.Enable.Value,
		Coder: shouldCoderTrace,
		Default: cfg.Trace.Enable.Value,
		Coder: shouldCoderTrace,
		Honeycomb: cfg.Trace.HoneycombAPIKey.Value,
		})
		if err != nil {
		logger.Warn(ctx, "start telemetry exporter", slog.Error(err))
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -95,7 +95,7 @@ func speedtest() *cobra.Command {
		dir = tsspeedtest.Upload
		}
		cmd.Printf("Starting a %ds %s test...\n", int(duration.Seconds()), dir)
		results, err := conn.Speedtest(dir, duration)
		results, err := conn.Speedtest(ctx,dir, duration)
		if err != nil {
		return err
		}
Expand Down