tenseleyflow/shithub / 11badfd

+- `shithub_actions_queue_depth{resource="runs|jobs"}`

+- `shithub_actions_active{resource="runs|jobs"}`

+- `shithub_actions_runner_heartbeat_age_seconds{runner,status}`

+- `shithub_actions_runner_capacity{runner,status}`

+- `shithub_actions_runs_completed_total{event,conclusion}`

+- `shithub_actions_run_duration_seconds{event,conclusion}`

+- `shithub_actions_steps_completed_total{step_type,conclusion}`

+- `shithub_actions_log_chunks_total{location="server"}`

+- `shithub_actions_log_chunk_bytes_total{location="server"}`

+- `shithub_actions_storage_objects{kind="artifacts|step_logs|hot_log_chunks"}`

+- `shithub_actions_storage_bytes{kind="artifacts|step_logs|hot_log_chunks"}`

+	actionstelemetry "github.com/tenseleyFlow/shithub/internal/actions/telemetry"

+		terminalRun   actionsdb.WorkflowRun

+		if runCompleted {

+			terminalRun = run

+		}

+	if runCompleted {

+		actionstelemetry.RecordRunTerminal(terminalRun)

+	}

+		terminalRun   actionsdb.WorkflowRun

+		if runCompleted {

+			terminalRun = run

+		}

+	if runCompleted {

+		actionstelemetry.RecordRunTerminal(terminalRun)

+	}

+// SPDX-License-Identifier: AGPL-3.0-or-later

+

+// Package telemetry records bounded-cardinality Actions metrics.

+package telemetry

+

+import (

+	"strings"

+

+	actionsdb "github.com/tenseleyFlow/shithub/internal/actions/sqlc"

+	"github.com/tenseleyFlow/shithub/internal/infra/metrics"

+)

+

+// RecordRunTerminal records terminal workflow-run counters and duration. It is

+// idempotency-sensitive: callers must invoke it only when a run first becomes

+// terminal.

+func RecordRunTerminal(run actionsdb.WorkflowRun) {

+	if !run.CompletedAt.Valid || !run.Conclusion.Valid {

+		return

+	}

+	start := run.CreatedAt.Time

+	if run.StartedAt.Valid {

+		start = run.StartedAt.Time

+	}

+	duration := run.CompletedAt.Time.Sub(start).Seconds()

+	if duration < 0 {

+		duration = 0

+	}

+	event := string(run.Event)

+	conclusion := string(run.Conclusion.CheckConclusion)

+	metrics.ActionsRunsCompletedTotal.WithLabelValues(event, conclusion).Inc()

+	metrics.ActionsRunDurationSeconds.WithLabelValues(event, conclusion).Observe(duration)

+}

+

+// RecordStepTerminal records terminal step outcomes using a bounded step_type

+// label. Do not label by user-authored step name; workflow YAML would then be

+// able to create unbounded Prometheus series.

+func RecordStepTerminal(step actionsdb.WorkflowStep) {

+	if !step.Conclusion.Valid {

+		return

+	}

+	metrics.ActionsStepsCompletedTotal.WithLabelValues(stepType(step), string(step.Conclusion.CheckConclusion)).Inc()

+}

+

+func stepType(step actionsdb.WorkflowStep) string {

+	uses := strings.TrimSpace(step.UsesAlias)

+	if uses != "" {

+		switch uses {

+		case "actions/checkout@v4":

+			return "checkout"

+		case "shithub/upload-artifact@v1":

+			return "upload-artifact"

+		case "shithub/download-artifact@v1":

+			return "download-artifact"

+		default:

+			return "uses"

+		}

+	}

+	return "run"

+}

+// SPDX-License-Identifier: AGPL-3.0-or-later

+

+package telemetry

+

+import (

+	"testing"

+	"time"

+

+	"github.com/jackc/pgx/v5/pgtype"

+	"github.com/prometheus/client_golang/prometheus"

+	dto "github.com/prometheus/client_model/go"

+

+	actionsdb "github.com/tenseleyFlow/shithub/internal/actions/sqlc"

+	"github.com/tenseleyFlow/shithub/internal/infra/metrics"

+)

+

+func TestRecordRunTerminalBoundsLabelsAndDuration(t *testing.T) {

+	metrics.ActionsRunsCompletedTotal.Reset()

+	metrics.ActionsRunDurationSeconds.Reset()

+

+	started := time.Date(2026, 5, 12, 10, 0, 0, 0, time.UTC)

+	completed := started.Add(75 * time.Second)

+	RecordRunTerminal(actionsdb.WorkflowRun{

+		Event:       actionsdb.WorkflowRunEvent("pull_request"),

+		Status:      actionsdb.WorkflowRunStatusCompleted,

+		Conclusion:  actionsdb.NullCheckConclusion{CheckConclusion: actionsdb.CheckConclusionSuccess, Valid: true},

+		StartedAt:   pgtype.Timestamptz{Time: started, Valid: true},

+		CompletedAt: pgtype.Timestamptz{Time: completed, Valid: true},

+	})

+

+	var completedMetric dto.Metric

+	if err := metrics.ActionsRunsCompletedTotal.WithLabelValues("pull_request", "success").Write(&completedMetric); err != nil {

+		t.Fatalf("read completed counter: %v", err)

+	}

+	if got := completedMetric.GetCounter().GetValue(); got != 1 {

+		t.Fatalf("completed counter = %v, want 1", got)

+	}

+

+	histogram, ok := metrics.ActionsRunDurationSeconds.WithLabelValues("pull_request", "success").(prometheus.Histogram)

+	if !ok {

+		t.Fatalf("duration metric is not a prometheus.Histogram")

+	}

+	var durationMetric dto.Metric

+	if err := histogram.Write(&durationMetric); err != nil {

+		t.Fatalf("read duration histogram: %v", err)

+	}

+	if got := durationMetric.GetHistogram().GetSampleCount(); got != 1 {

+		t.Fatalf("duration sample count = %v, want 1", got)

+	}

+	if got := durationMetric.GetHistogram().GetSampleSum(); got != 75 {

+		t.Fatalf("duration sample sum = %v, want 75", got)

+	}

+}

+

+func TestRecordStepTerminalUsesBoundedStepTypes(t *testing.T) {

+	metrics.ActionsStepsCompletedTotal.Reset()

+

+	RecordStepTerminal(actionsdb.WorkflowStep{

+		UsesAlias:  "actions/checkout@v4",

+		Status:     actionsdb.WorkflowStepStatusCompleted,

+		Conclusion: actionsdb.NullCheckConclusion{CheckConclusion: actionsdb.CheckConclusionSuccess, Valid: true},

+	})

+	RecordStepTerminal(actionsdb.WorkflowStep{

+		StepName:   "user controlled label with high cardinality potential",

+		UsesAlias:  "owner/custom-action@v1",

+		Status:     actionsdb.WorkflowStepStatusCompleted,

+		Conclusion: actionsdb.NullCheckConclusion{CheckConclusion: actionsdb.CheckConclusionFailure, Valid: true},

+	})

+	RecordStepTerminal(actionsdb.WorkflowStep{

+		RunCommand: "go test ./...",

+		Status:     actionsdb.WorkflowStepStatusCompleted,

+		Conclusion: actionsdb.NullCheckConclusion{CheckConclusion: actionsdb.CheckConclusionSuccess, Valid: true},

+	})

+

+	assertStepCounter(t, "checkout", "success", 1)

+	assertStepCounter(t, "uses", "failure", 1)

+	assertStepCounter(t, "run", "success", 1)

+}

+

+func assertStepCounter(t *testing.T, stepType, conclusion string, want float64) {

+	t.Helper()

+	var metric dto.Metric

+	if err := metrics.ActionsStepsCompletedTotal.WithLabelValues(stepType, conclusion).Write(&metric); err != nil {

+		t.Fatalf("read step counter %s/%s: %v", stepType, conclusion, err)

+	}

+	if got := metric.GetCounter().GetValue(); got != want {

+		t.Fatalf("step counter %s/%s = %v, want %v", stepType, conclusion, got, want)

+	}

+}

+// SPDX-License-Identifier: AGPL-3.0-or-later

+

+package metrics

+

+import (

+	"context"

+	"time"

+

+	"github.com/jackc/pgx/v5/pgxpool"

+)

+

+// ObserveActions starts a goroutine that periodically refreshes DB-backed

+// Actions gauges. The goroutine exits when ctx is canceled.

+func ObserveActions(ctx context.Context, pool *pgxpool.Pool, interval time.Duration) {

+	if pool == nil {

+		return

+	}

+	if interval <= 0 {

+		interval = 15 * time.Second

+	}

+	go func() {

+		refreshActions(ctx, pool)

+		t := time.NewTicker(interval)

+		defer t.Stop()

+		for {

+			select {

+			case <-ctx.Done():

+				return

+			case <-t.C:

+				refreshActions(ctx, pool)

+			}

+		}

+	}()

+}

+

+func refreshActions(ctx context.Context, pool *pgxpool.Pool) {

+	if pool == nil {

+		return

+	}

+	refreshActionQueueGauges(ctx, pool)

+	refreshActionRunnerGauges(ctx, pool)

+	refreshActionStorageGauges(ctx, pool)

+}

+

+func refreshActionQueueGauges(ctx context.Context, pool *pgxpool.Pool) {

+	ActionsQueueDepth.WithLabelValues("runs").Set(0)

+	ActionsQueueDepth.WithLabelValues("jobs").Set(0)

+	ActionsActive.WithLabelValues("runs").Set(0)

+	ActionsActive.WithLabelValues("jobs").Set(0)

+

+	rows, err := pool.Query(ctx, `

+SELECT 'runs'::text AS resource, status::text, count(*)::double precision

+FROM workflow_runs

+WHERE status IN ('queued', 'running')

+GROUP BY status

+UNION ALL

+SELECT 'jobs'::text AS resource, status::text, count(*)::double precision

+FROM workflow_jobs

+WHERE status IN ('queued', 'running')

+GROUP BY status`)

+	if err != nil {

+		return

+	}

+	defer rows.Close()

+	for rows.Next() {

+		var resource, status string

+		var count float64

+		if err := rows.Scan(&resource, &status, &count); err != nil {

+			return

+		}

+		switch status {

+		case "queued":

+			ActionsQueueDepth.WithLabelValues(resource).Set(count)

+		case "running":

+			ActionsActive.WithLabelValues(resource).Set(count)

+		}

+	}

+}

+

+func refreshActionRunnerGauges(ctx context.Context, pool *pgxpool.Pool) {

+	ActionsRunnerHeartbeatAgeSeconds.Reset()

+	ActionsRunnerCapacity.Reset()

+	rows, err := pool.Query(ctx, `

+SELECT name::text,

+       status::text,

+       capacity::double precision,

+       EXTRACT(EPOCH FROM (now() - last_heartbeat_at))::double precision AS heartbeat_age_seconds

+FROM workflow_runners

+WHERE last_heartbeat_at IS NOT NULL`)

+	if err != nil {

+		return

+	}

+	defer rows.Close()

+	for rows.Next() {

+		var name, status string

+		var capacity, age float64

+		if err := rows.Scan(&name, &status, &capacity, &age); err != nil {

+			return

+		}

+		ActionsRunnerCapacity.WithLabelValues(name, status).Set(capacity)

+		ActionsRunnerHeartbeatAgeSeconds.WithLabelValues(name, status).Set(age)

+	}

+}

+

+func refreshActionStorageGauges(ctx context.Context, pool *pgxpool.Pool) {

+	ActionsStorageObjects.WithLabelValues("artifacts").Set(0)

+	ActionsStorageObjects.WithLabelValues("step_logs").Set(0)

+	ActionsStorageObjects.WithLabelValues("hot_log_chunks").Set(0)

+	ActionsStorageBytes.WithLabelValues("artifacts").Set(0)

+	ActionsStorageBytes.WithLabelValues("step_logs").Set(0)

+	ActionsStorageBytes.WithLabelValues("hot_log_chunks").Set(0)

+

+	rows, err := pool.Query(ctx, `

+SELECT 'artifacts'::text AS kind, count(*)::double precision, COALESCE(sum(byte_count), 0)::double precision

+FROM workflow_artifacts

+UNION ALL

+SELECT 'step_logs'::text AS kind, count(*)::double precision, COALESCE(sum(log_byte_count), 0)::double precision

+FROM workflow_steps

+WHERE log_object_key IS NOT NULL

+UNION ALL

+SELECT 'hot_log_chunks'::text AS kind, count(*)::double precision, COALESCE(sum(octet_length(chunk)), 0)::double precision

+FROM workflow_step_log_chunks`)

+	if err != nil {

+		return

+	}

+	defer rows.Close()

+	for rows.Next() {

+		var kind string

+		var objects, bytes float64

+		if err := rows.Scan(&kind, &objects, &bytes); err != nil {

+			return

+		}

+		ActionsStorageObjects.WithLabelValues(kind).Set(objects)

+		ActionsStorageBytes.WithLabelValues(kind).Set(bytes)

+	}

+}

+// SPDX-License-Identifier: AGPL-3.0-or-later

+

+package metrics

+

+import (

+	"context"

+	"testing"

+	"time"

+

+	"github.com/jackc/pgx/v5/pgtype"

+	"github.com/prometheus/client_golang/prometheus"

+	dto "github.com/prometheus/client_model/go"

+

+	actionsdb "github.com/tenseleyFlow/shithub/internal/actions/sqlc"

+	reposdb "github.com/tenseleyFlow/shithub/internal/repos/sqlc"

+	"github.com/tenseleyFlow/shithub/internal/testing/dbtest"

+	usersdb "github.com/tenseleyFlow/shithub/internal/users/sqlc"

+)

+

+func TestRefreshActionsPublishesQueueRunnerAndStorageGauges(t *testing.T) {

+	ctx := context.Background()

+	pool := dbtest.NewTestDB(t)

+	q := actionsdb.New()

+

+	user, err := usersdb.New().CreateUser(ctx, pool, usersdb.CreateUserParams{

+		Username:     "metrics-observer",

+		DisplayName:  "Metrics Observer",

+		PasswordHash: "hash",

+	})

+	if err != nil {

+		t.Fatalf("CreateUser: %v", err)

+	}

+	repo, err := reposdb.New().CreateRepo(ctx, pool, reposdb.CreateRepoParams{

+		OwnerUserID:   pgtype.Int8{Int64: user.ID, Valid: true},

+		Name:          "actions-metrics",

+		DefaultBranch: "trunk",

+		Visibility:    reposdb.RepoVisibilityPublic,

+	})

+	if err != nil {

+		t.Fatalf("CreateRepo: %v", err)

+	}

+

+	run, err := q.InsertWorkflowRun(ctx, pool, actionsdb.InsertWorkflowRunParams{

+		RepoID:       repo.ID,

+		RunIndex:     1,

+		WorkflowFile: ".shithub/workflows/ci.yml",

+		WorkflowName: "CI",

+		HeadSha:      "0123456789abcdef0123456789abcdef01234567",

+		HeadRef:      "trunk",

+		Event:        actionsdb.WorkflowRunEventPush,

+		EventPayload: []byte(`{}`),

+		ActorUserID:  pgtype.Int8{Int64: user.ID, Valid: true},

+	})

+	if err != nil {

+		t.Fatalf("InsertWorkflowRun: %v", err)

+	}

+	job, err := q.InsertWorkflowJob(ctx, pool, actionsdb.InsertWorkflowJobParams{

+		RunID:          run.ID,

+		JobIndex:       0,

+		JobKey:         "build",

+		JobName:        "Build",

+		RunsOn:         `["ubuntu-latest"]`,

+		TimeoutMinutes: 30,

+		Permissions:    []byte(`{}`),

+		JobEnv:         []byte(`{}`),

+	})

+	if err != nil {

+		t.Fatalf("InsertWorkflowJob: %v", err)

+	}

+	step, err := q.InsertWorkflowStep(ctx, pool, actionsdb.InsertWorkflowStepParams{

+		JobID:            job.ID,

+		StepIndex:        0,

+		StepID:           "test",

+		StepName:         "Test",

+		RunCommand:       "go test ./...",

+		WorkingDirectory: ".",

+		StepEnv:          []byte(`{}`),

+		StepWith:         []byte(`{}`),

+	})

+	if err != nil {

+		t.Fatalf("InsertWorkflowStep: %v", err)

+	}

+	if _, err := pool.Exec(ctx, `UPDATE workflow_steps SET log_object_key = $1, log_byte_count = $2 WHERE id = $3`, "actions/logs/test.log", int64(123), step.ID); err != nil {

+		t.Fatalf("mark step log object: %v", err)

+	}

+	if _, err := q.AppendStepLogChunk(ctx, pool, actionsdb.AppendStepLogChunkParams{

+		StepID: step.ID,

+		Seq:    0,

+		Chunk:  []byte("hello"),

+	}); err != nil {

+		t.Fatalf("AppendStepLogChunk: %v", err)

+	}

+	if _, err := q.InsertArtifact(ctx, pool, actionsdb.InsertArtifactParams{

+		RunID:     run.ID,

+		Name:      "bundle",

+		ObjectKey: "actions/artifacts/bundle.zip",

+		ByteCount: 2048,

+		ExpiresAt: pgtype.Timestamptz{

+			Time:  time.Now().UTC().Add(24 * time.Hour),

+			Valid: true,

+		},

+	}); err != nil {

+		t.Fatalf("InsertArtifact: %v", err)

+	}

+	runner, err := q.InsertRunner(ctx, pool, actionsdb.InsertRunnerParams{

+		Name:               "runner-a",

+		Labels:             []string{"self-hosted", "linux", "ubuntu-latest"},

+		Capacity:           3,

+		RegisteredByUserID: pgtype.Int8{Int64: user.ID, Valid: true},

+	})

+	if err != nil {

+		t.Fatalf("InsertRunner: %v", err)

+	}

+	if _, err := pool.Exec(ctx, `UPDATE workflow_runners SET status = 'busy', last_heartbeat_at = now() - interval '75 seconds' WHERE id = $1`, runner.ID); err != nil {

+		t.Fatalf("touch runner heartbeat: %v", err)

+	}

+

+	resetActionsObserverGauges()

+	refreshActions(ctx, pool)

+

+	assertGauge(t, ActionsQueueDepth, []string{"runs"}, 1)

+	assertGauge(t, ActionsQueueDepth, []string{"jobs"}, 1)

+	assertGauge(t, ActionsActive, []string{"runs"}, 0)

+	assertGauge(t, ActionsActive, []string{"jobs"}, 0)

+	assertGauge(t, ActionsRunnerCapacity, []string{"runner-a", "busy"}, 3)

+	if got := gaugeValue(t, ActionsRunnerHeartbeatAgeSeconds, []string{"runner-a", "busy"}); got < 60 {

+		t.Fatalf("runner heartbeat age = %v, want >= 60", got)

+	}

+	assertGauge(t, ActionsStorageObjects, []string{"artifacts"}, 1)

+	assertGauge(t, ActionsStorageBytes, []string{"artifacts"}, 2048)

+	assertGauge(t, ActionsStorageObjects, []string{"step_logs"}, 1)

+	assertGauge(t, ActionsStorageBytes, []string{"step_logs"}, 123)

+	assertGauge(t, ActionsStorageObjects, []string{"hot_log_chunks"}, 1)

+	assertGauge(t, ActionsStorageBytes, []string{"hot_log_chunks"}, 5)

+}

+

+type labeledGauge interface {

+	WithLabelValues(lvs ...string) prometheus.Gauge

+}

+

+func resetActionsObserverGauges() {

+	ActionsQueueDepth.Reset()

+	ActionsActive.Reset()

+	ActionsRunnerHeartbeatAgeSeconds.Reset()

+	ActionsRunnerCapacity.Reset()

+	ActionsStorageObjects.Reset()

+	ActionsStorageBytes.Reset()

+}

+

+func assertGauge(t *testing.T, vec labeledGauge, labels []string, want float64) {

+	t.Helper()

+	if got := gaugeValue(t, vec, labels); got != want {

+		t.Fatalf("gauge %v = %v, want %v", labels, got, want)

+	}

+}

+

+func gaugeValue(t *testing.T, vec labeledGauge, labels []string) float64 {

+	t.Helper()

+	var metric dto.Metric

+	if err := vec.WithLabelValues(labels...).Write(&metric); err != nil {

+		t.Fatalf("read gauge %v: %v", labels, err)

+	}

+	if metric.Gauge == nil {

+		t.Fatalf("gauge %v missing", labels)

+	}

+	return metric.Gauge.GetValue()

+}

+	ActionsRunsCompletedTotal = prometheus.NewCounterVec(

+		prometheus.CounterOpts{

+			Name: "shithub_actions_runs_completed_total",

+			Help: "Total terminal Actions workflow runs by event kind and conclusion.",

+		},

+		[]string{"event", "conclusion"},

+	)

+	ActionsRunDurationSeconds = prometheus.NewHistogramVec(

+		prometheus.HistogramOpts{

+			Name:    "shithub_actions_run_duration_seconds",

+			Help:    "Actions workflow run duration from started_at or created_at to completed_at, by event kind and conclusion.",

+			Buckets: prometheus.ExponentialBuckets(1, 2.5, 12),

+		},

+		[]string{"event", "conclusion"},

+	)

+	ActionsStepsCompletedTotal = prometheus.NewCounterVec(

+		prometheus.CounterOpts{

+			Name: "shithub_actions_steps_completed_total",

+			Help: "Total terminal Actions steps by bounded step type and conclusion.",

+		},

+		[]string{"step_type", "conclusion"},

+	)

+	ActionsLogChunksTotal = prometheus.NewCounterVec(

+		prometheus.CounterOpts{

+			Name: "shithub_actions_log_chunks_total",

+			Help: "Total Actions log chunks accepted by location.",

+		},

+		[]string{"location"},

+	)

+	ActionsLogChunkBytesTotal = prometheus.NewCounterVec(

+		prometheus.CounterOpts{

+			Name: "shithub_actions_log_chunk_bytes_total",

+			Help: "Total Actions log chunk bytes accepted by location before durable storage.",

+		},

+		[]string{"location"},

+	)

+	ActionsQueueDepth = prometheus.NewGaugeVec(

+		prometheus.GaugeOpts{

+			Name: "shithub_actions_queue_depth",

+			Help: "Current queued Actions workflow items by resource (runs, jobs).",

+		},

+		[]string{"resource"},

+	)

+	ActionsActive = prometheus.NewGaugeVec(

+		prometheus.GaugeOpts{

+			Name: "shithub_actions_active",

+			Help: "Current running Actions workflow items by resource (runs, jobs).",

+		},

+		[]string{"resource"},

+	)

+	ActionsRunnerHeartbeatAgeSeconds = prometheus.NewGaugeVec(

+		prometheus.GaugeOpts{

+			Name: "shithub_actions_runner_heartbeat_age_seconds",

+			Help: "Seconds since each registered Actions runner last heartbeated. Offline runners that never heartbeated are omitted.",

+		},

+		[]string{"runner", "status"},

+	)

+	ActionsRunnerCapacity = prometheus.NewGaugeVec(

+		prometheus.GaugeOpts{

+			Name: "shithub_actions_runner_capacity",

+			Help: "Configured Actions runner capacity by runner and status.",

+		},

+		[]string{"runner", "status"},

+	)

+	ActionsStorageObjects = prometheus.NewGaugeVec(

+		prometheus.GaugeOpts{

+			Name: "shithub_actions_storage_objects",

+			Help: "Current durable Actions storage object count by kind.",

+		},

+		[]string{"kind"},

+	)

+	ActionsStorageBytes = prometheus.NewGaugeVec(

+		prometheus.GaugeOpts{

+			Name: "shithub_actions_storage_bytes",

+			Help: "Current durable Actions storage byte count by kind.",

+		},

+		[]string{"kind"},

+	)

+		ActionsRunsCompletedTotal,

+		ActionsRunDurationSeconds,

+		ActionsStepsCompletedTotal,

+		ActionsLogChunksTotal,

+		ActionsLogChunkBytesTotal,

+		ActionsQueueDepth,

+		ActionsActive,

+		ActionsRunnerHeartbeatAgeSeconds,

+		ActionsRunnerCapacity,

+		ActionsStorageObjects,

+		ActionsStorageBytes,

+	actionstelemetry "github.com/tenseleyFlow/shithub/internal/actions/telemetry"

+	if terminal && stepLifecycleChanged(step, updated) {

+		actionstelemetry.RecordStepTerminal(updated)

+	}

+	if runTerminalChanged {

+		actionstelemetry.RecordRunTerminal(runAfter)

+	}

+func stepLifecycleChanged(before, after actionsdb.WorkflowStep) bool {

+	if before.Status != after.Status {

+		return true

+	}

+	if before.Conclusion.Valid != after.Conclusion.Valid {

+		return true

+	}

+	return before.Conclusion.Valid && before.Conclusion.CheckConclusion != after.Conclusion.CheckConclusion

+}

+

+	acceptedChunkBytes := len(chunk)

+		metrics.ActionsLogChunksTotal.WithLabelValues("server").Inc()

+		metrics.ActionsLogChunkBytesTotal.WithLabelValues("server").Add(float64(acceptedChunkBytes))

+	accepted := false

+		accepted = true

+	if accepted {

+		if replacements > 0 {

+			metrics.ActionsLogScrubReplacementsTotal.WithLabelValues("server").Add(float64(replacements))

+		}

+		metrics.ActionsLogChunksTotal.WithLabelValues("server").Inc()

+		metrics.ActionsLogChunkBytesTotal.WithLabelValues("server").Add(float64(acceptedChunkBytes))

+			metrics.ObserveActions(ctx, pool, 15*time.Second)