feat: add OpenTelemetry tracing export (OTLP/HTTP)

README.md

@@ -16,6 +16,7 @@ Gitte keeps all your repos in sync, runs startup checks to verify your local mac
 - [Commands](#commands)
 - [Configuration](#configuration)
 - [Environment variables](#environment-variables)
+- [Telemetry](#telemetry)
 - [Global flags](#global-flags)
 - [State and override files](#state-and-override-files)
 
@@ -170,6 +171,58 @@ See [docs/config.md](./docs/config.md) for the full configuration reference.
 
 ---
 
+## Telemetry
+
+Gitte can export OpenTelemetry traces to an OTLP/HTTP endpoint (e.g. Elastic
+APM) to help debug failures. Traces capture per-repo git context (branch,
+commit SHA, dirty state) and per-task outcomes with errors. To identify which
+developer and machine hit a failure, the OS username (`user.name`) and hostname
+(`host.name`) are attached to every trace.
+
+**What is recorded:** the gitte CLI arguments and each action's command line are
+exported as span attributes (this is intentional — knowing what ran is the
+point). Note that gitte's **injected** environment — a project's `env`,
+`env_when`, and feature-gate env — is also exported on task spans (the
+`gitte.env` attribute) and in the task logs; the inherited **process**
+environment (everything in `os.Environ`) is **not**. So keep secrets out of
+action command definitions, CLI arguments, and config `env`/feature-gate blocks
+— pass real secrets through the process environment instead. Full remote URLs
+are never collected either (repos are identified by name only).
+
+Each `gitte run` produces a structured trace: a root span with child spans for
+each phase (`startup`, `gitops`, `actions`), a span per startup check, a span
+per action (e.g. `build`, `up`) parenting its task spans, and a span per repo
+sync. Action and startup command output is also shipped as **OTEL logs**,
+correlated to the span that produced each line (stdout → INFO, stderr → WARN).
+
+Logs are enabled with tracing; set `GITTE_TELEMETRY_LOGS=off` to keep traces but
+disable the (higher-volume) log export. Keep secrets out of command output —
+log lines are exported verbatim.
+
+Enable it via the shared config:
+
+```yaml
+telemetry:
+  endpoint: https://apm.example.com:8200
+  headers:
+    Authorization: "Bearer <secret-token>"   # or: "ApiKey <base64-key>"
+```
+
+Environment variables:
+
+| Variable | Effect |
+|---|---|
+| `GITTE_TELEMETRY=off` | Disable telemetry locally (kill-switch) |
+| `GITTE_TELEMETRY_URL` | Override the endpoint |
+| `GITTE_TELEMETRY_LOGS=off` | Disable OTEL log export (keep traces) |
+| `OTEL_EXPORTER_OTLP_ENDPOINT` / `OTEL_EXPORTER_OTLP_HEADERS` | Standard OTEL env vars, honored as a fallback when no gitte endpoint is set |
+
+Precedence: `GITTE_TELEMETRY=off` > `GITTE_TELEMETRY_URL` > config endpoint >
+`OTEL_EXPORTER_OTLP_*`. Telemetry is best-effort and never blocks or slows
+gitte; export failures are silently ignored.
+
+---
+
 ## Global flags
 
 ```

actions/features_test.go

@@ -0,0 +1,69 @@
+package actions
+
+import (
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/cego/gitte/config"
+	"github.com/cego/gitte/state"
+)
+
+func TestEnabledFeaturesForProject(t *testing.T) {
+	cfg := &config.GitteConfig{
+		FeatureGates: map[string]config.FeatureGate{
+			"feat-on":         {},                                                        // empty scope → applies to all projects
+			"feat-off":        {},                                                        // disabled in state
+			"feat-scoped-out": {Scope: config.FeatureScope{Projects: []string{"other"}}}, // enabled but scoped to a different project
+		},
+	}
+	st := &state.GitteState{Features: map[string]state.FeatureState{
+		"feat-on":         {Enabled: true},
+		"feat-off":        {Enabled: false},
+		"feat-scoped-out": {Enabled: true},
+	}}
+	proj := config.ProjectConfig{Remote: "git@github.com:example/myproj.git"}
+
+	got := enabledFeaturesForProject(cfg, st, "myproj", proj)
+	want := []string{"feat-on"}
+	if !reflect.DeepEqual(got, want) {
+		t.Fatalf("enabledFeaturesForProject = %v, want %v", got, want)
+	}
+}
+
+func TestInjectedEnv(t *testing.T) {
+	cfg := &config.GitteConfig{
+		FeatureGates: map[string]config.FeatureGate{
+			"feat-on": {Effects: config.FeatureEffects{Env: map[string]string{"FEAT_VAR": "1"}}},
+		},
+	}
+	st := &state.GitteState{Features: map[string]state.FeatureState{"feat-on": {Enabled: true}}}
+	proj := config.ProjectConfig{
+		Remote: "git@github.com:example/myproj.git",
+		Env:    map[string]string{"PROJ_VAR": "x"},
+	}
+	got := injectedEnv(cfg, st, "myproj", proj)
+	if got["PROJ_VAR"] != "x" || got["FEAT_VAR"] != "1" {
+		t.Fatalf("injectedEnv = %v, want PROJ_VAR=x and FEAT_VAR=1", got)
+	}
+}
+
+func TestOutputTail(t *testing.T) {
+	// stderr preferred when non-empty
+	if got := outputTail([]byte("the real error"), []byte("noise")); got != "the real error" {
+		t.Fatalf("stderr-preferred: got %q", got)
+	}
+	// falls back to stdout when stderr is blank (e.g. gitlab-ci-local prints to stdout)
+	if got := outputTail([]byte("   \n"), []byte("stdout failure")); got != "stdout failure" {
+		t.Fatalf("stdout-fallback: got %q", got)
+	}
+	// capped to the last errorTailBytes
+	big := []byte(strings.Repeat("x", errorTailBytes+500))
+	if got := outputTail(big, nil); len(got) != errorTailBytes {
+		t.Fatalf("cap: len=%d, want %d", len(got), errorTailBytes)
+	}
+	// empty when no output
+	if got := outputTail(nil, nil); got != "" {
+		t.Fatalf("empty: got %q", got)
+	}
+}