simplify the telemetry disabled reporting logic

hugodutka · hugodutka · commit 363ea1172f55 · 2025-01-31T13:54:44.000Z
diff --git a/coderd/telemetry/telemetry.go b/coderd/telemetry/telemetry.go
@@ -158,12 +158,6 @@ func (r *remoteReporter) reportSync(snapshot *Snapshot) {
 		r.options.Logger.Debug(r.ctx, "bad response from telemetry server", slog.F("status", resp.StatusCode))
 		return
 	}
-	if err := r.options.Database.UpsertTelemetryItem(r.ctx, database.UpsertTelemetryItemParams{
-		Key:   string(TelemetryItemKeyLastTelemetryUpdate),
-		Value: "",
-	}); err != nil {
-		r.options.Logger.Debug(r.ctx, "upsert last telemetry update", slog.Error(err))
-	}
 	r.options.Logger.Debug(r.ctx, "submitted snapshot")
 }
 
@@ -194,7 +188,18 @@ func (r *remoteReporter) isClosed() bool {
 	}
 }
 
+func (r *remoteReporter) recordTelemetryEnabled() {
+	if err := r.options.Database.UpsertTelemetryItem(r.ctx, database.UpsertTelemetryItemParams{
+		Key:   string(TelemetryItemKeyTelemetryEnabled),
+		Value: "",
+	}); err != nil {
+		r.options.Logger.Debug(r.ctx, "upsert last telemetry report", slog.Error(err))
+	}
+}
+
 func (r *remoteReporter) RunSnapshotter() {
+	r.recordTelemetryEnabled()
+
 	first := true
 	ticker := time.NewTicker(r.options.SnapshotFrequency)
 	defer ticker.Stop()
@@ -349,17 +354,26 @@ func checkIDPOrgSync(ctx context.Context, db database.Store, values *codersdk.De
 
 func (r *remoteReporter) ReportDisabledIfNeeded() error {
 	db := r.options.Database
-	lastTelemetryUpdate, telemetryUpdateErr := db.GetTelemetryItem(r.ctx, string(TelemetryItemKeyLastTelemetryUpdate))
-	if telemetryUpdateErr != nil && !errors.Is(telemetryUpdateErr, sql.ErrNoRows) {
-		r.options.Logger.Debug(r.ctx, "get last telemetry update at", slog.Error(telemetryUpdateErr))
+	telemetryEnabled, telemetryEnabledErr := db.GetTelemetryItem(r.ctx, string(TelemetryItemKeyTelemetryEnabled))
+	if telemetryEnabledErr != nil && !errors.Is(telemetryEnabledErr, sql.ErrNoRows) {
+		r.options.Logger.Debug(r.ctx, "get telemetry enabled", slog.Error(telemetryEnabledErr))
 	}
 	telemetryDisabled, telemetryDisabledErr := db.GetTelemetryItem(r.ctx, string(TelemetryItemKeyTelemetryDisabled))
 	if telemetryDisabledErr != nil && !errors.Is(telemetryDisabledErr, sql.ErrNoRows) {
 		r.options.Logger.Debug(r.ctx, "get telemetry disabled", slog.Error(telemetryDisabledErr))
 	}
-	shouldReportDisabledTelemetry := telemetryUpdateErr == nil &&
-		((telemetryDisabledErr == nil && lastTelemetryUpdate.UpdatedAt.Before(telemetryDisabled.UpdatedAt)) ||
-			errors.Is(telemetryDisabledErr, sql.ErrNoRows))
+	// There are 2 scenarios in which we want to report the disabled telemetry:
+	// 1. The telemetry was enabled at some point, and we haven't reported the disabled telemetry yet.
+	// 2. The telemetry was enabled at some point, we reported the disabled telemetry, the telemetry
+	//    was enabled again, and then disabled again.
+	//
+	// - In both cases, the TelemetryEnabled item will be present.
+	// - In case 1. the TelemetryDisabled item will not be present.
+	// - In case 2. the TelemetryDisabled item will be present, and the TelemetryEnabled item will
+	//   be more recent than the TelemetryDisabled item.
+	shouldReportDisabledTelemetry := telemetryEnabledErr == nil &&
+		(errors.Is(telemetryDisabledErr, sql.ErrNoRows) ||
+			(telemetryDisabledErr == nil && telemetryEnabled.UpdatedAt.After(telemetryDisabled.UpdatedAt)))
 	if !shouldReportDisabledTelemetry {
 		return nil
 	}
@@ -1616,9 +1630,9 @@ type Organization struct {
 type TelemetryItemKey string
 
 const (
-	TelemetryItemKeyHTMLFirstServedAt   TelemetryItemKey = "html_first_served_at"
-	TelemetryItemKeyLastTelemetryUpdate TelemetryItemKey = "last_telemetry_update"
-	TelemetryItemKeyTelemetryDisabled   TelemetryItemKey = "telemetry_disabled"
+	TelemetryItemKeyHTMLFirstServedAt TelemetryItemKey = "html_first_served_at"
+	TelemetryItemKeyTelemetryEnabled  TelemetryItemKey = "telemetry_enabled"
+	TelemetryItemKeyTelemetryDisabled TelemetryItemKey = "telemetry_disabled"
 )
 
 type TelemetryItem struct {
diff --git a/coderd/telemetry/telemetry_test.go b/coderd/telemetry/telemetry_test.go
@@ -365,27 +365,28 @@ func TestReportDisabledIfNeeded(t *testing.T) {
 	t.Parallel()
 	db, _ := dbtestutil.NewDB(t)
 	ctx := testutil.Context(t, testutil.WaitMedium)
-	serverURL, _, snapshotChan := setupTelemetryServer(t)
+	serverURL, _, snapshotChan := mockTelemetryServer(t)
 
 	options := telemetry.Options{
-		Database:     db,
-		Logger:       testutil.Logger(t),
-		URL:          serverURL,
-		DeploymentID: uuid.NewString(),
+		Database:             db,
+		Logger:               testutil.Logger(t),
+		URL:                  serverURL,
+		DeploymentID:         uuid.NewString(),
+		DisableReportOnClose: true,
 	}
 
 	reporter, err := telemetry.New(options)
 	require.NoError(t, err)
 	t.Cleanup(reporter.Close)
 
-	// No telemetry updated item, so no report should be sent
+	// No telemetry enabled item, so no report should be sent
 	require.NoError(t, reporter.ReportDisabledIfNeeded())
 	require.Empty(t, snapshotChan)
 
-	// Telemetry disabled item not present, and a telemetry update item present
+	// Telemetry enabled item present, and a telemetry disabled item not present
 	// Report should be sent
 	_ = dbgen.TelemetryItem(t, db, database.TelemetryItem{
-		Key:   string(telemetry.TelemetryItemKeyLastTelemetryUpdate),
+		Key:   string(telemetry.TelemetryItemKeyTelemetryEnabled),
 		Value: "",
 	})
 	require.NoError(t, reporter.ReportDisabledIfNeeded())
@@ -397,19 +398,17 @@ func TestReportDisabledIfNeeded(t *testing.T) {
 		t.Fatal("timeout waiting for snapshot")
 	}
 
-	// Telemetry disabled item present, and a telemetry update item present
-	// with an updated at time equal to or after the telemetry disabled item
+	// Telemetry enabled item present, and a more recent telemetry disabled item present
 	// Report should not be sent
 	require.NoError(t, reporter.ReportDisabledIfNeeded())
 	require.Empty(t, snapshotChan)
 
-	// Telemetry disabled item present, and a telemetry update item present
-	// with an updated at time before the telemetry disabled item
+	// Telemetry enabled item present, and a less recent telemetry disabled item present
 	// Report should be sent
-	// Wait a bit to ensure UpdatedAt is bigger when we upsert the telemetry disabled item
+	// Wait a bit to ensure UpdatedAt is bigger when we upsert the telemetry enabled item
 	time.Sleep(100 * time.Millisecond)
 	require.NoError(t, db.UpsertTelemetryItem(ctx, database.UpsertTelemetryItemParams{
-		Key:   string(telemetry.TelemetryItemKeyTelemetryDisabled),
+		Key:   string(telemetry.TelemetryItemKeyTelemetryEnabled),
 		Value: "",
 	}))
 	require.NoError(t, reporter.ReportDisabledIfNeeded())
@@ -422,7 +421,7 @@ func TestReportDisabledIfNeeded(t *testing.T) {
 	}
 }
 
-func setupTelemetryServer(t *testing.T) (*url.URL, chan *telemetry.Deployment, chan *telemetry.Snapshot) {
+func mockTelemetryServer(t *testing.T) (*url.URL, chan *telemetry.Deployment, chan *telemetry.Snapshot) {
 	t.Helper()
 	deployment := make(chan *telemetry.Deployment, 64)
 	snapshot := make(chan *telemetry.Snapshot, 64)
@@ -456,7 +455,7 @@ func setupTelemetryServer(t *testing.T) (*url.URL, chan *telemetry.Deployment, c
 func collectSnapshot(t *testing.T, db database.Store, addOptionsFn func(opts telemetry.Options) telemetry.Options) (*telemetry.Deployment, *telemetry.Snapshot) {
 	t.Helper()
 
-	serverURL, deployment, snapshot := setupTelemetryServer(t)
+	serverURL, deployment, snapshot := mockTelemetryServer(t)
 
 	options := telemetry.Options{
 		Database:     db,
