fix(tracer): flush telemetry when Stop is called

ddtrace/tracer/telemetry_test.go

@@ -18,6 +18,7 @@ import (
 	"github.com/DataDog/dd-trace-go/v2/internal/orchestrion"
 	"github.com/DataDog/dd-trace-go/v2/internal/telemetry"
 	"github.com/DataDog/dd-trace-go/v2/internal/telemetry/telemetrytest"
+	"github.com/DataDog/dd-trace-go/v2/internal/traceprof"
 	"github.com/DataDog/dd-trace-go/v2/profiler"
 
 	"github.com/stretchr/testify/assert"
@@ -232,3 +233,64 @@ func TestRepeatStartRecordsEnvDiffOnActiveClient(t *testing.T) {
 	require.True(t, ok, "expected config.repeat_start_env_diff to be recorded on the active telemetry client")
 	assert.Equal(t, float64(1), handle.Get())
 }
+
+func TestTracerStopFlushesTelemetry(t *testing.T) {
+	Start()
+	defer globalconfig.SetServiceName("")
+	require.NotNil(t, telemetry.GlobalClient())
+
+	Stop()
+
+	assert.Nil(t, telemetry.GlobalClient())
+}
+
+func TestTracerStopDoesNotStopForeignTelemetry(t *testing.T) {
+	telemetryClient := new(telemetrytest.RecordClient)
+	defer telemetry.MockClient(telemetryClient)()
+
+	Start()
+	defer globalconfig.SetServiceName("")
+	Stop()
+
+	// Profiler or another product already owns the global client. Stop must
+	// not call StopApp on it.
+	assert.False(t, telemetryClient.Stopped)
+	assert.Equal(t, telemetry.Client(telemetryClient), telemetry.GlobalClient())
+	// ProductStopped(tracers) must still propagate to the foreign client
+	// (ProductStarted set it true during Start; Stop sets it back to false).
+	assert.False(t, telemetryClient.Products[telemetry.NamespaceTracers])
+}
+
+func TestTracerStopKeepsTelemetryWhenProfilerStillRunning(t *testing.T) {
+	Start()
+	defer globalconfig.SetServiceName("")
+	require.NotNil(t, telemetry.GlobalClient())
+
+	wasEnabled := traceprof.SetProfilerEnabled(true)
+	defer func() {
+		traceprof.SetProfilerEnabled(wasEnabled)
+		telemetry.StopApp()
+	}()
+
+	Stop()
+
+	// Profiler started after the tracer and still shares the client, so Stop
+	// must flush without emitting app-stopped / clearing the global client.
+	assert.NotNil(t, telemetry.GlobalClient())
+}
+
+func TestTracerStopStopsTelemetryAfterProfilerStopped(t *testing.T) {
+	Start()
+	defer globalconfig.SetServiceName("")
+	require.NotNil(t, telemetry.GlobalClient())
+
+	wasEnabled := traceprof.SetProfilerEnabled(true)
+	defer traceprof.SetProfilerEnabled(wasEnabled)
+	// The profiler started after the tracer, then stopped before tracer.Stop().
+	traceprof.SetProfilerEnabled(false)
+
+	Stop()
+
+	// Nobody else needs the client anymore, so Stop must fully stop the app.
+	assert.Nil(t, telemetry.GlobalClient())
+}

ddtrace/tracer/tracer.go

@@ -132,6 +132,8 @@ type tracer struct {
 
 	// stopOnce ensures the tracer is stopped exactly once.
 	stopOnce sync.Once
+	// telemetryStopOnce ensures telemetry shutdown runs once across concurrent Stop calls.
+	telemetryStopOnce sync.Once
 
 	// wg waits for all goroutines to exit when stopping.
 	wg sync.WaitGroup
@@ -1271,13 +1273,39 @@ func (t *tracer) Stop() {
 	}
 	appsec.Stop()
 	remoteconfig.Stop()
+	// Flush telemetry before closing the log file so StopApp diagnostics still land.
+	// Interim tracer/profiler ownership handshake for the global telemetry client;
+	// to be superseded by shared client control (see TODO at newTracer, APMAPI-1771).
+	t.telemetryStopOnce.Do(func() {
+		client := t.telemetry
+		t.telemetry = nil
+		if client == nil {
+			return
+		}
+		telemetry.ProductStopped(telemetry.NamespaceTracers)
+		if telemetry.GlobalClient() != client {
+			// StartApp ignored this client because another product already owns
+			// the global one. Close the leftover so its ticker does not leak.
+			client.Close()
+			return
+		}
+		if traceprof.ProfilerEnabled() {
+			// Profiler started after us and still shares this client. Mark the
+			// tracer product stopped and flush, but leave the app running.
+			// TODO: profiler.Stop() never stops telemetry, so when the profiler is
+			// the last product to stop, app-stopped is never sent and the client's
+			// ticker goroutine lives until process exit. Follow-up: profiler.Stop()
+			// should send ProductStopped(NamespaceProfilers) and StopApp() when it
+			// owns the global client.
+			client.Flush()
+			return
+		}
+		telemetry.StopApp()
+	})
 	// Close log file last to account for any logs from the above calls
 	if t.logFile != nil {
 		t.logFile.Close()
 	}
-	if t.telemetry != nil {
-		t.telemetry.Close()
-	}
 	t.config.httpClient.CloseIdleConnections()
 }
 

internal/traceprof/profiler.go

@@ -17,6 +17,11 @@ func SetProfilerEnabled(val bool) bool {
 	return profiler.enabled.Swap(boolToUint32(val)) != 0
 }
 
+// ProfilerEnabled reports whether the continuous profiler is currently running.
+func ProfilerEnabled() bool {
+	return profiler.enabled.Load() != 0
+}
+
 func profilerEnabled() int {
 	return int(profiler.enabled.Load())
 }

profiler/profiler.go

@@ -81,6 +81,8 @@ func Start(opts ...Option) error {
 
 	if activeProfiler != nil {
 		activeProfiler.stop()
+		activeProfiler = nil
+		traceprof.SetProfilerEnabled(false)
 	}
 	p, err := newProfiler(opts...)
 	if err != nil {
@@ -90,8 +92,10 @@ func Start(opts ...Option) error {
 		return nil
 	}
 	activeProfiler = p
-	activeProfiler.run()
+	// Raise the flag before run() so tracer.Stop() sees the profiler as active
+	// while startTelemetry registers on the shared client (avoids a TOCTOU close).
 	traceprof.SetProfilerEnabled(true)
+	activeProfiler.run()
 	return nil
 }
 

profiler/profiler_test.go

@@ -174,6 +174,20 @@ func TestStart(t *testing.T) {
 		defer Stop()
 		assert.ErrorIs(t, err, errProfilingNotSupportedInAWSLambda)
 	})
+
+	t.Run("restart-disabled-clears-enabled-flag", func(t *testing.T) {
+		require.NoError(t, Start())
+		require.True(t, traceprof.ProfilerEnabled())
+
+		t.Setenv("DD_PROFILING_ENABLED", "false")
+		require.NoError(t, Start())
+		defer Stop()
+
+		mu.Lock()
+		assert.Nil(t, activeProfiler)
+		mu.Unlock()
+		assert.False(t, traceprof.ProfilerEnabled())
+	})
 }
 
 // TestStartWithoutStopReconfigures verifies that calling Start while the