ReportDisabledIfNeeded

hugodutka · hugodutka · commit 325314be7c5a · 2025-01-30T16:26:27.000Z
diff --git a/cli/server.go b/cli/server.go
@@ -814,11 +814,31 @@ func (r *RootCmd) Server(newAPI func(context.Context, *coderd.Options) (*coderd.
 				if err != nil {
 					return xerrors.Errorf("create telemetry reporter: %w", err)
 				}
+				go options.Telemetry.RunSnapshotter()
 				defer options.Telemetry.Close()
 			} else {
 				logger.Warn(ctx, fmt.Sprintf(`telemetry disabled, unable to notify of security issues. Read more: %s/admin/setup/telemetry`, vals.DocsURL.String()))
 			}
 
+			if !vals.Telemetry.Enable.Value() {
+				go func() {
+					reporter, err := telemetry.New(telemetry.Options{
+						DeploymentID: deploymentID,
+						Database:     options.Database,
+						Logger:       logger.Named("telemetry"),
+						URL:          vals.Telemetry.URL.Value(),
+					})
+					if err != nil {
+						logger.Debug(ctx, "create telemetry reporter (disabled)", slog.Error(err))
+						return
+					}
+					defer reporter.Close()
+					if err := reporter.ReportDisabledIfNeeded(); err != nil {
+						logger.Debug(ctx, "failed to report disabled telemetry", slog.Error(err))
+					}
+				}()
+			}
+
 			// This prevents the pprof import from being accidentally deleted.
 			_ = pprof.Handler
 			if vals.Pprof.Enable {
diff --git a/coderd/telemetry/telemetry.go b/coderd/telemetry/telemetry.go
@@ -59,6 +59,9 @@ type Options struct {
 // New constructs a reporter for telemetry data.
 // Duplicate data will be sent, it's on the server-side to index by UUID.
 // Data is anonymized prior to being sent!
+//
+// The returned Reporter should be started with RunSnapshotter() to begin
+// reporting.
 func New(options Options) (Reporter, error) {
 	if options.SnapshotFrequency == 0 {
 		// Report once every 30mins by default!
@@ -83,7 +86,6 @@ func New(options Options) (Reporter, error) {
 		snapshotURL:   snapshotURL,
 		startedAt:     dbtime.Now(),
 	}
-	go reporter.runSnapshotter()
 	return reporter, nil
 }
 
@@ -101,6 +103,12 @@ type Reporter interface {
 	Report(snapshot *Snapshot)
 	Enabled() bool
 	Close()
+	// RunSnapshotter runs reporting in a loop. It should be called in a
+	// goroutine to avoid blocking the caller.
+	RunSnapshotter()
+	// ReportDisabledIfNeeded reports disabled telemetry if there was at least one report sent
+	// before the telemetry was disabled, and we haven't sent a report since the telemetry was disabled.
+	ReportDisabledIfNeeded() error
 }
 
 type remoteReporter struct {
@@ -149,6 +157,12 @@ 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: dbtime.Now().Format(time.RFC3339),
+	}); err != nil {
+		r.options.Logger.Debug(r.ctx, "upsert last telemetry update", slog.Error(err))
+	}
 	r.options.Logger.Debug(r.ctx, "submitted snapshot")
 }
 
@@ -177,7 +191,7 @@ func (r *remoteReporter) isClosed() bool {
 	}
 }
 
-func (r *remoteReporter) runSnapshotter() {
+func (r *remoteReporter) RunSnapshotter() {
 	first := true
 	ticker := time.NewTicker(r.options.SnapshotFrequency)
 	defer ticker.Stop()
@@ -330,6 +344,45 @@ func checkIDPOrgSync(ctx context.Context, db database.Store, values *codersdk.De
 	return syncConfig.Field != "", nil
 }
 
+func (r *remoteReporter) ReportDisabledIfNeeded() error {
+	db := r.options.Database
+	lastTelemetryUpdate, telemetryUpdateErr := db.GetTelemetryItem(r.ctx, string(TelemetryItemKeyLastTelemetryUpdate))
+	if telemetryUpdateErr != nil {
+		r.options.Logger.Debug(r.ctx, "get last telemetry update at", slog.Error(telemetryUpdateErr))
+	}
+	telemetryDisabled, telemetryDisabledErr := db.GetTelemetryItem(r.ctx, string(TelemetryItemKeyTelemetryDisabled))
+	if telemetryDisabledErr != nil {
+		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))
+	if !shouldReportDisabledTelemetry {
+		return nil
+	}
+
+	if err := db.UpsertTelemetryItem(r.ctx, database.UpsertTelemetryItemParams{
+		Key:   string(TelemetryItemKeyTelemetryDisabled),
+		Value: time.Now().Format(time.RFC3339),
+	}); err != nil {
+		return xerrors.Errorf("upsert telemetry disabled: %w", err)
+	}
+	item, err := db.GetTelemetryItem(r.ctx, string(TelemetryItemKeyTelemetryDisabled))
+	if err != nil {
+		return xerrors.Errorf("get telemetry disabled: %w", err)
+	}
+
+	r.reportSync(
+		&Snapshot{
+			TelemetryItems: []TelemetryItem{
+				ConvertTelemetryItem(item),
+			},
+		},
+	)
+	return nil
+}
+
 // createSnapshot collects a full snapshot from the database.
 func (r *remoteReporter) createSnapshot() (*Snapshot, error) {
 	var (
@@ -1561,7 +1614,9 @@ type Organization struct {
 type TelemetryItemKey string
 
 const (
-	TelemetryItemKeyHTMLFirstServedAt TelemetryItemKey = "html_first_served_at"
+	TelemetryItemKeyHTMLFirstServedAt   TelemetryItemKey = "html_first_served_at"
+	TelemetryItemKeyLastTelemetryUpdate TelemetryItemKey = "last_telemetry_update"
+	TelemetryItemKeyTelemetryDisabled   TelemetryItemKey = "telemetry_disabled"
 )
 
 type TelemetryItem struct {
@@ -1573,6 +1628,8 @@ type TelemetryItem struct {
 
 type noopReporter struct{}
 
-func (*noopReporter) Report(_ *Snapshot) {}
-func (*noopReporter) Enabled() bool      { return false }
-func (*noopReporter) Close()             {}
+func (*noopReporter) Report(_ *Snapshot)            {}
+func (*noopReporter) Enabled() bool                 { return false }
+func (*noopReporter) Close()                        {}
+func (*noopReporter) RunSnapshotter()               {}
+func (*noopReporter) ReportDisabledIfNeeded() error { return nil }
diff --git a/coderd/telemetry/telemetry_test.go b/coderd/telemetry/telemetry_test.go
@@ -398,6 +398,7 @@ func collectSnapshot(t *testing.T, db database.Store, addOptionsFn func(opts tel
 
 	reporter, err := telemetry.New(options)
 	require.NoError(t, err)
+	go reporter.RunSnapshotter()
 	t.Cleanup(reporter.Close)
 	return <-deployment, <-snapshot
 }

Original file line number	Diff line number	Diff line change
`@@ -398,6 +398,7 @@ func collectSnapshot(t *testing.T, db database.Store, addOptionsFn func(opts tel`
`398`	`398`
`399`	`399`	`reporter, err := telemetry.New(options)`
`400`	`400`	`require.NoError(t, err)`
	`401`	`+ go reporter.RunSnapshotter()`
`401`	`402`	`t.Cleanup(reporter.Close)`
`402`	`403`	`return <-deployment, <-snapshot`
`403`	`404`	`}`