Dangerous Context Enrichment

by passing the Sentry Context down our abstraction stack.
This included changes in the complex context management of managing a Command Execution.

internal/nomad/api_querier.go

@@ -7,6 +7,7 @@ import (
 	"github.com/gorilla/websocket"
 	nomadApi "github.com/hashicorp/nomad/api"
 	"github.com/openHPI/poseidon/internal/config"
+	"github.com/openHPI/poseidon/pkg/logging"
 	"io"
 )
 
@@ -88,18 +89,30 @@ func (nc *nomadAPIClient) Execute(runnerID string,
 	ctx context.Context, command []string, tty bool,
 	stdin io.Reader, stdout, stderr io.Writer,
 ) (int, error) {
-	allocations, _, err := nc.client.Jobs().Allocations(runnerID, false, nil)
+	var allocations []*nomadApi.AllocationListStub
+	var err error
+	logging.StartSpan("nomad.execute.list", "List Allocations for id", ctx, func(_ context.Context) {
+		allocations, _, err = nc.client.Jobs().Allocations(runnerID, false, nil)
+	})
 	if err != nil {
 		return 1, fmt.Errorf("error retrieving allocations for runner: %w", err)
 	}
 	if len(allocations) == 0 {
 		return 1, ErrorNoAllocationFound
 	}
-	allocation, _, err := nc.client.Allocations().Info(allocations[0].ID, nil)
+
+	var allocation *nomadApi.Allocation
+	logging.StartSpan("nomad.execute.info", "List Data of Allocation", ctx, func(_ context.Context) {
+		allocation, _, err = nc.client.Allocations().Info(allocations[0].ID, nil)
+	})
 	if err != nil {
 		return 1, fmt.Errorf("error retrieving allocation info: %w", err)
 	}
-	exitCode, err := nc.client.Allocations().Exec(ctx, allocation, TaskName, tty, command, stdin, stdout, stderr, nil, nil)
+
+	var exitCode int
+	logging.StartSpan("nomad.execute.exec", "Execute Command in Allocation", ctx, func(ctx context.Context) {
+		exitCode, err = nc.client.Allocations().Exec(ctx, allocation, TaskName, tty, command, stdin, stdout, stderr, nil, nil)
+	})
 	switch {
 	case err == nil:
 		return exitCode, nil

internal/nomad/nomad.go

@@ -421,16 +421,22 @@ func (a *APIClient) executeCommandInteractivelyWithStderr(allocationID string, c
 		defer cancel()
 
 		// Catch stderr in separate execution.
-		exit, err := a.Execute(allocationID, ctx, prepareCommandTTYStdErr(currentNanoTime, privilegedExecution), true,
-			nullio.Reader{Ctx: readingContext}, stderr, io.Discard)
-		if err != nil {
-			log.WithError(err).WithField("runner", allocationID).Warn("Stderr task finished with error")
-		}
-		stderrExitChan <- exit
+		logging.StartSpan("nomad.execute.stderr", "Execution for separate StdErr", ctx, func(ctx context.Context) {
+			exit, err := a.Execute(allocationID, ctx, prepareCommandTTYStdErr(currentNanoTime, privilegedExecution), true,
+				nullio.Reader{Ctx: readingContext}, stderr, io.Discard)
+			if err != nil {
+				log.WithError(err).WithField("runner", allocationID).Warn("Stderr task finished with error")
+			}
+			stderrExitChan <- exit
+		})
 	}()
 
 	command = prepareCommandTTY(command, currentNanoTime, privilegedExecution)
-	exit, err := a.Execute(allocationID, ctx, command, true, stdin, stdout, io.Discard)
+	var exit int
+	var err error
+	logging.StartSpan("nomad.execute.tty", "Interactive Execution", ctx, func(ctx context.Context) {
+		exit, err = a.Execute(allocationID, ctx, command, true, stdin, stdout, io.Discard)
+	})
 
 	// Wait until the stderr catch command finished to make sure we receive all output.
 	<-stderrExitChan

internal/nomad/nomad_test.go

@@ -784,7 +784,7 @@ func (s *ExecuteCommandTestSuite) TestWithoutSeparateStderrReturnsCommandError()
 
 func (s *ExecuteCommandTestSuite) mockExecute(command interface{}, exitCode int,
 	err error, runFunc func(arguments mock.Arguments)) *mock.Call {
-	return s.apiMock.On("Execute", s.allocationID, s.ctx, command, withTTY,
+	return s.apiMock.On("Execute", s.allocationID, mock.Anything, command, withTTY,
 		mock.Anything, mock.Anything, mock.Anything).
 		Run(runFunc).
 		Return(exitCode, err)