chore: Send instrumentation data on kill

chore: ensure to kill CLI processes

Author: PeterSchafer

cliv2/cmd/cliv2/instrumentation.go

@@ -4,14 +4,19 @@ package main
 import _ "github.com/snyk/go-application-framework/pkg/networking/fips_enable"
 
 import (
+	"context"
+	"encoding/json"
 	"os/exec"
+	"strconv"
 	"strings"
 	"time"
 
+	"github.com/rs/zerolog"
 	"github.com/snyk/go-application-framework/pkg/analytics"
 	"github.com/snyk/go-application-framework/pkg/configuration"
 	"github.com/snyk/go-application-framework/pkg/instrumentation"
 
+	"github.com/snyk/cli/cliv2/internal/constants"
 	cli_utils "github.com/snyk/cli/cliv2/internal/utils"
 
 	localworkflows "github.com/snyk/go-application-framework/pkg/local_workflows"
@@ -74,3 +79,76 @@ func updateInstrumentationDataBeforeSending(cliAnalytics analytics.Analytics, st
 		cliAnalytics.GetInstrumentation().SetStatus(analytics.Failure)
 	}
 }
+
+func sendAnalytics(ctx context.Context, a analytics.Analytics, debugLogger *zerolog.Logger) {
+	debugLogger.Print("Sending Analytics")
+
+	a.SetApiUrl(globalConfiguration.GetString(configuration.API_URL))
+
+	request, err := a.GetRequest()
+	if err != nil {
+		debugLogger.Err(err).Msg("Failed to create Analytics request")
+		return
+	}
+
+	// Use context to respect teardown timeout
+	request = request.WithContext(ctx)
+
+	client := globalEngine.GetNetworkAccess().GetHttpClient()
+	res, err := client.Do(request)
+	if err != nil {
+		debugLogger.Err(err).Msg("Failed to send Analytics")
+		return
+	}
+	defer func() {
+		_ = res.Body.Close()
+	}()
+
+	successfullySend := 200 <= res.StatusCode && res.StatusCode < 300
+	if successfullySend {
+		debugLogger.Print("Analytics successfully send")
+	} else {
+		debugLogger.Print("Failed to send Analytics:", res.Status)
+	}
+}
+
+func sendInstrumentation(ctx context.Context, eng workflow.Engine, instrumentor analytics.InstrumentationCollector, logger *zerolog.Logger) {
+	// Avoid duplicate data to be sent for IDE integrations that use the CLI
+	if !shallSendInstrumentation(eng.GetConfiguration(), instrumentor) {
+		logger.Print("This CLI call is not instrumented!")
+		return
+	}
+
+	// add temporary static nodejs binary flag, remove once linuxstatic is official
+	staticNodeJsBinaryBool, parseErr := strconv.ParseBool(constants.StaticNodeJsBinary)
+	if parseErr != nil {
+		logger.Print("Failed to parse staticNodeJsBinary:", parseErr)
+	} else {
+		// the legacycli:: prefix is added to maintain compatibility with our monitoring dashboard
+		instrumentor.AddExtension("legacycli::static-nodejs-binary", staticNodeJsBinaryBool)
+	}
+
+	logger.Print("Sending Instrumentation")
+	data, err := analytics.GetV2InstrumentationObject(instrumentor, analytics.WithLogger(logger))
+	if err != nil {
+		logger.Err(err).Msg("Failed to derive data object")
+	}
+
+	v2InstrumentationData := utils.ValueOf(json.Marshal(data))
+	localConfiguration := globalConfiguration.Clone()
+	// the report analytics workflow needs --experimental to run
+	// we pass the flag here so that we report at every interaction
+	localConfiguration.Set(configuration.FLAG_EXPERIMENTAL, true)
+	localConfiguration.Set("inputData", string(v2InstrumentationData))
+	_, err = eng.Invoke(
+		localworkflows.WORKFLOWID_REPORT_ANALYTICS,
+		workflow.WithConfig(localConfiguration),
+		workflow.WithContext(ctx),
+	)
+
+	if err != nil {
+		logger.Err(err).Msg("Failed to send Instrumentation")
+	} else {
+		logger.Print("Instrumentation successfully sent")
+	}
+}

cliv2/cmd/cliv2/main.go

@@ -11,9 +11,10 @@ import (
 	"io"
 	"os"
 	"os/exec"
-	"strconv"
+	"os/signal"
 	"strings"
 	"sync"
+	"syscall"
 	"time"
 
 	"github.com/google/uuid"
@@ -88,6 +89,7 @@ const (
 	debug_level_flag          string = "log-level"
 	integrationNameFlag       string = "integration-name"
 	maxNetworkRequestAttempts string = "max-attempts"
+	teardownTimeout                  = 5 * time.Second
 )
 
 type JsonErrorStruct struct {
@@ -221,71 +223,6 @@ func runWorkflowAndProcessData(engine workflow.Engine, logger *zerolog.Logger, n
 	return err
 }
 
-func sendAnalytics(analytics analytics.Analytics, debugLogger *zerolog.Logger) {
-	debugLogger.Print("Sending Analytics")
-
-	analytics.SetApiUrl(globalConfiguration.GetString(configuration.API_URL))
-
-	res, err := analytics.Send()
-	if err != nil {
-		debugLogger.Err(err).Msg("Failed to send Analytics")
-		return
-	}
-	defer func() { _ = res.Body.Close() }()
-
-	successfullySend := 200 <= res.StatusCode && res.StatusCode < 300
-	if successfullySend {
-		debugLogger.Print("Analytics successfully send")
-	} else {
-		var details string
-		if res != nil {
-			details = res.Status
-		}
-
-		debugLogger.Print("Failed to send Analytics:", details)
-	}
-}
-
-func sendInstrumentation(eng workflow.Engine, instrumentor analytics.InstrumentationCollector, logger *zerolog.Logger) {
-	// Avoid duplicate data to be sent for IDE integrations that use the CLI
-	if !shallSendInstrumentation(eng.GetConfiguration(), instrumentor) {
-		logger.Print("This CLI call is not instrumented!")
-		return
-	}
-
-	// add temporary static nodejs binary flag, remove once linuxstatic is official
-	staticNodeJsBinaryBool, parseErr := strconv.ParseBool(constants.StaticNodeJsBinary)
-	if parseErr != nil {
-		logger.Print("Failed to parse staticNodeJsBinary:", parseErr)
-	} else {
-		// the legacycli:: prefix is added to maintain compatibility with our monitoring dashboard
-		instrumentor.AddExtension("legacycli::static-nodejs-binary", staticNodeJsBinaryBool)
-	}
-
-	logger.Print("Sending Instrumentation")
-	data, err := analytics.GetV2InstrumentationObject(instrumentor, analytics.WithLogger(logger))
-	if err != nil {
-		logger.Err(err).Msg("Failed to derive data object")
-	}
-
-	v2InstrumentationData := utils.ValueOf(json.Marshal(data))
-	localConfiguration := globalConfiguration.Clone()
-	// the report analytics workflow needs --experimental to run
-	// we pass the flag here so that we report at every interaction
-	localConfiguration.Set(configuration.FLAG_EXPERIMENTAL, true)
-	localConfiguration.Set("inputData", string(v2InstrumentationData))
-	_, err = eng.InvokeWithConfig(
-		localworkflows.WORKFLOWID_REPORT_ANALYTICS,
-		localConfiguration,
-	)
-
-	if err != nil {
-		logger.Err(err).Msg("Failed to send Instrumentation")
-	} else {
-		logger.Print("Instrumentation successfully sent")
-	}
-}
-
 func help(_ *cobra.Command, _ []string) error {
 	helpProvided = true
 	args := utils.RemoveSimilar(os.Args[1:], "--") // remove all double dash arguments to avoid issues with the help command
@@ -548,11 +485,55 @@ func initExtensions(engine workflow.Engine, config configuration.Configuration)
 	}
 }
 
+// tearDown handles sending analytics and instrumentation
+// It is used both for normal exit and signal-triggered exit
+func tearDown(ctx context.Context, err error, errorList []error, startTime time.Time, ua networking.UserAgentInfo, cliAnalytics analytics.Analytics, networkAccess networking.NetworkAccess) int {
+	// Create a context with timeout for teardown operations to ensure we don't hang indefinitely
+	teardownCtx, cancel := context.WithTimeout(ctx, teardownTimeout)
+	defer cancel()
+
+	if err != nil {
+		errorList, err = processError(err, errorList)
+
+		for _, tempError := range errorList {
+			if tempError != nil {
+				cliAnalytics.AddError(tempError)
+			}
+		}
+	}
+
+	exitCode := cliv2.DeriveExitCode(err)
+	globalLogger.Printf("Deriving Exit Code %d (cause: %v)", exitCode, err)
+
+	displayError(err, globalEngine.GetUserInterface(), globalConfiguration, teardownCtx)
+
+	updateInstrumentationDataBeforeSending(cliAnalytics, startTime, ua, exitCode)
+
+	if !globalConfiguration.GetBool(configuration.ANALYTICS_DISABLED) {
+		sendAnalytics(teardownCtx, cliAnalytics, globalLogger)
+	}
+	sendInstrumentation(teardownCtx, globalEngine, cliAnalytics.GetInstrumentation(), globalLogger)
+
+	// cleanup resources in use
+	// WARNING: deferred actions will execute AFTER cleanup; only defer if not impacted by this
+	if _, cleanupErr := globalEngine.Invoke(basic_workflows.WORKFLOWID_GLOBAL_CLEANUP, workflow.WithContext(teardownCtx)); cleanupErr != nil {
+		globalLogger.Printf("Failed to cleanup %v", cleanupErr)
+	}
+
+	if globalConfiguration.GetBool(configuration.DEBUG) {
+		writeLogFooter(exitCode, errorList, globalConfiguration, networkAccess)
+	}
+
+	return exitCode
+}
+
 func MainWithErrorCode() int {
 	initDebugBuild()
 
 	errorList := []error{}
 	errorListMutex := sync.Mutex{}
+	var tearDownOnce sync.Once
+	var finalExitCode int
 
 	startTime := time.Now()
 	var err error
@@ -656,6 +637,32 @@ func MainWithErrorCode() int {
 	cliAnalytics.GetInstrumentation().SetStage(instrumentation.DetermineStage(cliAnalytics.IsCiEnvironment()))
 	cliAnalytics.GetInstrumentation().SetStatus(analytics.Success)
 
+	// prepare for signal handling
+	signalChan := make(chan os.Signal, 1)
+	exitCodeChan := make(chan int, 1)
+
+	if globalConfiguration.GetBool(configuration.PREVIEW_FEATURES_ENABLED) {
+		// Set up signal handling to send instrumentation on premature termination
+		signal.Notify(signalChan, syscall.SIGINT, syscall.SIGTERM)
+		go func() {
+			sig := <-signalChan
+			globalLogger.Printf("Received signal %v, attempting to send instrumentation before exit", sig)
+
+			tearDownOnce.Do(func() {
+				signalError := cli.NewTerminatedBySignalError(fmt.Sprintf("Signal: %v", sig))
+
+				errorListMutex.Lock()
+				errorListCopy := append([]error{}, errorList...)
+				errorListMutex.Unlock()
+
+				finalExitCode = tearDown(ctx, signalError, errorListCopy, startTime, ua, cliAnalytics, networkAccess)
+			})
+			// Send exit code to main goroutine instead of calling os.Exit directly
+			// This allows deferred functions (like lock cleanup) to run
+			exitCodeChan <- finalExitCode
+		}()
+	}
+
 	setTimeout(globalConfiguration, func() {
 		os.Exit(constants.SNYK_EXIT_CODE_EX_UNAVAILABLE)
 	})
@@ -681,40 +688,29 @@ func MainWithErrorCode() int {
 		// ignore
 	}
 
-	if err != nil {
-		errorList, err = processError(err, errorList)
-
-		for _, tempError := range errorList {
-			if tempError != nil {
-				cliAnalytics.AddError(tempError)
-			}
-		}
+	// Check if signal handler already ran teardown
+	select {
+	case code := <-exitCodeChan:
+		// Signal was received and teardown completed - return its exit code
+		return code
+	default:
+		// No signal received - run normal teardown
 	}
 
-	displayError(err, globalEngine.GetUserInterface(), globalConfiguration, ctx)
-
-	exitCode := cliv2.DeriveExitCode(err)
-	globalLogger.Printf("Deriving Exit Code %d (cause: %v)", exitCode, err)
-
-	updateInstrumentationDataBeforeSending(cliAnalytics, startTime, ua, exitCode)
-
-	if !globalConfiguration.GetBool(configuration.ANALYTICS_DISABLED) {
-		sendAnalytics(cliAnalytics, globalLogger)
+	if globalConfiguration.GetBool(configuration.PREVIEW_FEATURES_ENABLED) {
+		// Stop signal handling before cleanup to prevent race conditions
+		signal.Stop(signalChan)
 	}
-	sendInstrumentation(globalEngine, cliAnalytics.GetInstrumentation(), globalLogger)
 
-	// cleanup resources in use
-	// WARNING: deferred actions will execute AFTER cleanup; only defer if not impacted by this
-	_, err = globalEngine.Invoke(basic_workflows.WORKFLOWID_GLOBAL_CLEANUP)
-	if err != nil {
-		globalLogger.Printf("Failed to cleanup %v", err)
-	}
+	tearDownOnce.Do(func() {
+		errorListMutex.Lock()
+		errorListCopy := append([]error{}, errorList...)
+		errorListMutex.Unlock()
 
-	if debugEnabled {
-		writeLogFooter(exitCode, errorList, globalConfiguration, networkAccess)
-	}
+		finalExitCode = tearDown(ctx, err, errorListCopy, startTime, ua, cliAnalytics, networkAccess)
+	})
 
-	return exitCode
+	return finalExitCode
 }
 
 func processError(err error, errorList []error) ([]error, error) {

cliv2/go.mod

@@ -21,8 +21,8 @@ require (
 	github.com/snyk/cli-extension-secrets v0.0.0-20260330131056-456a17f6d188
 	github.com/snyk/code-client-go v1.26.2
 	github.com/snyk/container-cli v0.0.0-20260213211631-cd2b2cf8f3ea
-	github.com/snyk/error-catalog-golang-public v0.0.0-20260316131845-f02d7f42046b
-	github.com/snyk/go-application-framework v0.0.0-20260330124826-9560aa9edaf6
+	github.com/snyk/error-catalog-golang-public v0.0.0-20260326122451-686348fab429
+	github.com/snyk/go-application-framework v0.0.0-20260331101552-58f300cca5e1
 	github.com/snyk/go-httpauth v0.0.0-20240307114523-1f5ea3f55c65
 	github.com/snyk/snyk-iac-capture v0.6.5
 	github.com/snyk/snyk-ls v0.0.0-20260327145511-f13f911f19d3

cliv2/go.sum

@@ -559,10 +559,10 @@ github.com/snyk/container-cli v0.0.0-20260213211631-cd2b2cf8f3ea h1:/v48hCMPiZVj
 github.com/snyk/container-cli v0.0.0-20260213211631-cd2b2cf8f3ea/go.mod h1:P5yW8+jkwhYBsj5l2jtHeWujyX+SAtvkC8+LELKdlWI=
 github.com/snyk/dep-graph/go v0.0.0-20260127160647-c836da762c62 h1:kgZNQ5ztI4+n3YKLR5LJbqL8WJmUYgDSbFKREIY79g0=
 github.com/snyk/dep-graph/go v0.0.0-20260127160647-c836da762c62/go.mod h1:hTr91da/4ze2nk9q6ZW1BmfM2Z8rLUZSEZ3kK+6WGpc=
-github.com/snyk/error-catalog-golang-public v0.0.0-20260316131845-f02d7f42046b h1:DM2SPu7rhsD/TNS7zhv4ZoqLLi2cFOqg1VTBCP6RfSg=
-github.com/snyk/error-catalog-golang-public v0.0.0-20260316131845-f02d7f42046b/go.mod h1:Ytttq7Pw4vOCu9NtRQaOeDU2dhBYUyNBe6kX4+nIIQ4=
-github.com/snyk/go-application-framework v0.0.0-20260330124826-9560aa9edaf6 h1:Ltb6illIasRhS/MKZX2+uLtDyuxWWvDPYQJzv41EwM8=
-github.com/snyk/go-application-framework v0.0.0-20260330124826-9560aa9edaf6/go.mod h1:7IOOtKxiQhtTbkrX7rax20QNJ/rwGill6n2Rejtld2I=
+github.com/snyk/error-catalog-golang-public v0.0.0-20260326122451-686348fab429 h1:KUvautSov5PIOo3IQxbeu0d7zOVh5oO+sZ0N4lZkiJ8=
+github.com/snyk/error-catalog-golang-public v0.0.0-20260326122451-686348fab429/go.mod h1:Ytttq7Pw4vOCu9NtRQaOeDU2dhBYUyNBe6kX4+nIIQ4=
+github.com/snyk/go-application-framework v0.0.0-20260331101552-58f300cca5e1 h1:zMU74SVnhvYyKyMOqfgREqXjgyvYbtshp81X7GrL7dw=
+github.com/snyk/go-application-framework v0.0.0-20260331101552-58f300cca5e1/go.mod h1:7IOOtKxiQhtTbkrX7rax20QNJ/rwGill6n2Rejtld2I=
 github.com/snyk/go-httpauth v0.0.0-20240307114523-1f5ea3f55c65 h1:CEQuYv0Go6MEyRCD3YjLYM2u3Oxkx8GpCpFBd4rUTUk=
 github.com/snyk/go-httpauth v0.0.0-20240307114523-1f5ea3f55c65/go.mod h1:88KbbvGYlmLgee4OcQ19yr0bNpXpOr2kciOthaSzCAg=
 github.com/snyk/policy-engine v1.1.3 h1:MU+K8pxbN6VZ9P5wALUt8BwTjrPDpoEtmTtQqj7sKfY=

jest.config.js

@@ -5,5 +5,6 @@ module.exports = createJestConfig({
   displayName: 'coreCli',
   projects: ['<rootDir>', '<rootDir>/packages/*'],
   globalSetup: './test/setup.js',
+  globalTeardown: './test/teardown.js',
   setupFilesAfterEnv: ['./test/setup-jest.ts'],
 });