Skip to content

Modern Docker Management, Designed for Everyone

refactor: update analytics job to send manager or agent server type

Kyle Mendellf2cfe0fa7939
diff --git a/backend/internal/bootstrap/jobs_bootstrap.go b/backend/internal/bootstrap/jobs_bootstrap.go
index 182336a74..0bc6bd933 100644
--- a/backend/internal/bootstrap/jobs_bootstrap.go
+++ b/backend/internal/bootstrap/jobs_bootstrap.go
@@ -22,6 +22,8 @@ func registerJobs(appCtx context.Context, newScheduler *pkg_scheduler.JobSchedul
analyticsJob := pkg_scheduler.NewAnalyticsJob(appServices.Settings, nil, appConfig)
newScheduler.RegisterJob(analyticsJob)
+ // Send initial heartbeat on startup without blocking bootstrap.
+ go analyticsJob.Run(appCtx)
eventCleanupJob := pkg_scheduler.NewEventCleanupJob(appServices.Event, appServices.Settings)
newScheduler.RegisterJob(eventCleanupJob)
diff --git a/backend/pkg/scheduler/analytics_job.go b/backend/pkg/scheduler/analytics_job.go
index 6cadf5942..c53479f6e 100644
--- a/backend/pkg/scheduler/analytics_job.go
+++ b/backend/pkg/scheduler/analytics_job.go
@@ -19,6 +19,7 @@ import (
const (
AnalyticsJobName = "analytics-heartbeat"
defaultHeartbeatEndpoint = "https://checkin.getarcane.app/heartbeat"
+ devHeartbeatEndpoint = "http://localhost:8080/heartbeat"
)
type AnalyticsJob struct {
@@ -36,10 +37,14 @@ func NewAnalyticsJob(
if httpClient == nil {
httpClient = &http.Client{Timeout: 30 * time.Second}
}
+ heartbeatURL := defaultHeartbeatEndpoint
+ if !cfg.Environment.IsProdEnvironment() {
+ heartbeatURL = devHeartbeatEndpoint
+ }
return &AnalyticsJob{
settingsService: settingsService,
httpClient: httpClient,
- heartbeatURL: defaultHeartbeatEndpoint,
+ heartbeatURL: heartbeatURL,
cfg: cfg,
}
}
@@ -72,8 +77,12 @@ func (j *AnalyticsJob) Schedule(ctx context.Context) string {
}
func (j *AnalyticsJob) Run(ctx context.Context) {
- if j.cfg.AnalyticsDisabled || !j.cfg.Environment.IsProdEnvironment() {
- slog.DebugContext(ctx, "analytics disabled or not in production; skipping heartbeat", "analyticsDisabled", j.cfg.AnalyticsDisabled, "env", j.cfg.Environment)
+ if j.cfg.AnalyticsDisabled {
+ slog.DebugContext(ctx, "analytics disabled; skipping heartbeat", "analyticsDisabled", j.cfg.AnalyticsDisabled)
+ return
+ }
+ if j.cfg.Environment.IsTestEnvironment() {
+ slog.DebugContext(ctx, "test environment; skipping heartbeat", "env", j.cfg.Environment)
return
}
@@ -82,9 +91,11 @@ func (j *AnalyticsJob) Run(ctx context.Context) {
payload := struct {
Version string `json:"version"`
InstanceID string `json:"instance_id"`
+ ServerType string `json:"server_type,omitempty"`
}{
Version: getAnalyticsVersion(),
InstanceID: instanceID,
+ ServerType: j.getServerType(),
}
body, err := json.Marshal(payload)
@@ -93,7 +104,22 @@ func (j *AnalyticsJob) Run(ctx context.Context) {
return
}
- slog.InfoContext(ctx, "sending analytics heartbeat", "jobName", AnalyticsJobName)
+ slog.InfoContext(
+ ctx,
+ "sending analytics heartbeat",
+ "jobName",
+ AnalyticsJobName,
+ "version",
+ payload.Version,
+ "instanceID",
+ payload.InstanceID,
+ "serverType",
+ payload.ServerType,
+ "heartbeatURL",
+ j.heartbeatURL,
+ "env",
+ j.cfg.Environment,
+ )
_, err = backoff.Retry(
ctx,
@@ -127,7 +153,22 @@ func (j *AnalyticsJob) Run(ctx context.Context) {
return
}
- slog.InfoContext(ctx, "analytics heartbeat sent successfully", "jobName", AnalyticsJobName)
+ slog.InfoContext(
+ ctx,
+ "analytics heartbeat sent successfully",
+ "jobName",
+ AnalyticsJobName,
+ "version",
+ payload.Version,
+ "instanceID",
+ payload.InstanceID,
+ "serverType",
+ payload.ServerType,
+ "heartbeatURL",
+ j.heartbeatURL,
+ "env",
+ j.cfg.Environment,
+ )
}
func (j *AnalyticsJob) Reschedule(ctx context.Context) error {
@@ -135,6 +176,13 @@ func (j *AnalyticsJob) Reschedule(ctx context.Context) error {
return nil
}
+func (j *AnalyticsJob) getServerType() string {
+ if j.cfg.AgentMode {
+ return "agent"
+ }
+ return "manager"
+}
+
func getAnalyticsVersion() string {
if v := strings.TrimSpace(config.Version); v != "" && v != "dev" {
return v
diff --git a/backend/pkg/scheduler/analytics_job_test.go b/backend/pkg/scheduler/analytics_job_test.go
new file mode 100644
index 000000000..5159d8d8c
--- /dev/null
+++ b/backend/pkg/scheduler/analytics_job_test.go
@@ -0,0 +1,137 @@
+package scheduler
+
+import (
+ "context"
+ "encoding/json"
+ "io"
+ "net/http"
+ "net/http/httptest"
+ "testing"
+
+ glsqlite "github.com/glebarez/sqlite"
+ "github.com/stretchr/testify/require"
+ "gorm.io/gorm"
+
+ "github.com/getarcaneapp/arcane/backend/internal/config"
+ "github.com/getarcaneapp/arcane/backend/internal/database"
+ "github.com/getarcaneapp/arcane/backend/internal/models"
+ "github.com/getarcaneapp/arcane/backend/internal/services"
+)
+
+func setupAnalyticsSettingsService(t *testing.T) *services.SettingsService {
+ t.Helper()
+ ctx := context.Background()
+ db, err := gorm.Open(glsqlite.Open(":memory:"), &gorm.Config{})
+ require.NoError(t, err)
+ require.NoError(t, db.AutoMigrate(&models.SettingVariable{}))
+
+ svc, err := services.NewSettingsService(ctx, &database.DB{DB: db})
+ require.NoError(t, err)
+ require.NoError(t, svc.SetStringSetting(ctx, "instanceId", "test-instance"))
+
+ return svc
+}
+
+func newHeartbeatServer(t *testing.T) (*httptest.Server, <-chan []byte) {
+ t.Helper()
+ bodyCh := make(chan []byte, 1)
+
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ body, err := io.ReadAll(r.Body)
+ if err != nil {
+ t.Errorf("failed to read heartbeat body: %v", err)
+ }
+ bodyCh <- body
+ w.WriteHeader(http.StatusOK)
+ }))
+
+ return server, bodyCh
+}
+
+func TestAnalyticsJob_Run_ManagerPayload(t *testing.T) {
+ ctx := context.Background()
+ settingsService := setupAnalyticsSettingsService(t)
+ server, bodyCh := newHeartbeatServer(t)
+ defer server.Close()
+
+ cfg := &config.Config{Environment: config.AppEnvironmentProduction}
+ job := NewAnalyticsJob(settingsService, server.Client(), cfg)
+ job.heartbeatURL = server.URL
+
+ job.Run(ctx)
+
+ var body []byte
+ select {
+ case body = <-bodyCh:
+ default:
+ t.Fatal("expected heartbeat request")
+ }
+
+ var payload map[string]any
+ require.NoError(t, json.Unmarshal(body, &payload))
+ require.Equal(t, getAnalyticsVersion(), payload["version"])
+ require.Equal(t, "test-instance", payload["instance_id"])
+ require.Equal(t, "manager", payload["server_type"])
+}
+
+func TestAnalyticsJob_Run_AgentPayload(t *testing.T) {
+ ctx := context.Background()
+ settingsService := setupAnalyticsSettingsService(t)
+ server, bodyCh := newHeartbeatServer(t)
+ defer server.Close()
+
+ cfg := &config.Config{AgentMode: true, Environment: config.AppEnvironmentProduction}
+ job := NewAnalyticsJob(settingsService, server.Client(), cfg)
+ job.heartbeatURL = server.URL
+
+ job.Run(ctx)
+
+ var body []byte
+ select {
+ case body = <-bodyCh:
+ default:
+ t.Fatal("expected heartbeat request")
+ }
+
+ var payload map[string]any
+ require.NoError(t, json.Unmarshal(body, &payload))
+ require.Equal(t, "agent", payload["server_type"])
+}
+
+func TestAnalyticsJob_Run_SkipsWhenDisabled(t *testing.T) {
+ ctx := context.Background()
+ settingsService := setupAnalyticsSettingsService(t)
+ server, bodyCh := newHeartbeatServer(t)
+ defer server.Close()
+
+ cfg := &config.Config{AnalyticsDisabled: true, Environment: config.AppEnvironmentProduction}
+ job := NewAnalyticsJob(settingsService, server.Client(), cfg)
+ job.heartbeatURL = server.URL
+
+ job.Run(ctx)
+
+ select {
+ case <-bodyCh:
+ t.Fatal("unexpected heartbeat request")
+ default:
+ }
+}
+
+func TestAnalyticsJob_Run_SkipsWhenTestEnv(t *testing.T) {
+ ctx := context.Background()
+ settingsService := setupAnalyticsSettingsService(t)
+ server, bodyCh := newHeartbeatServer(t)
+ defer server.Close()
+
+ cfg := &config.Config{Environment: config.AppEnvironmentTest}
+ job := NewAnalyticsJob(settingsService, server.Client(), cfg)
+ job.heartbeatURL = server.URL
+
+ job.Run(ctx)
+
+ select {
+ case <-bodyCh:
+ t.Fatal("unexpected heartbeat request")
+ default:
+ }
+}