Telemetry integration for Cyclium.

Events

Episode lifecycle

[:cyclium, :episode, :started]      — %{episode_id, actor_id}
[:cyclium, :episode, :completed]    — %{episode_id, actor_id, output_count, finding_count}
[:cyclium, :episode, :failed]       — %{episode_id, actor_id, error_class}
[:cyclium, :episode, :blocked]      — %{episode_id, actor_id}
[:cyclium, :episode, :resumed]      — %{episode_id, actor_id}
[:cyclium, :episode, :dropped]      — %{actor_id, expectation_id}
[:cyclium, :episode, :queued]       — %{episode_id, actor_id}
[:cyclium, :episode, :canceled]     — %{episode_id, actor_id, reason}
[:cyclium, :episode, :sampled_out]  — %{actor_id, expectation_id}

Step events

[:cyclium, :step, :tool_call]       — %{tool, action, episode_id}
[:cyclium, :step, :synthesis]       — %{episode_id}
[:cyclium, :step, :output]          — %{type, status, episode_id}
[:cyclium, :step, :observation]     — %{actor_id, episode_id}

Budget events

[:cyclium, :budget, :tokens]        — %{episode_id, used, max, pct}
[:cyclium, :budget, :turns]         — %{episode_id, used, max, pct}

Actor events

[:cyclium, :actor, :event_received] — %{actor_id, event_type}
[:cyclium, :actor, :overflow]       — %{actor_id, policy, expectation_id}

Output events

[:cyclium, :output, :delivered]     — %{type, dedupe_key, ref}
[:cyclium, :output, :failed]        — %{type, dedupe_key, reason}
[:cyclium, :output, :deduplicated]  — %{type, dedupe_key}

Finding events

[:cyclium, :finding, :raised]       — %{finding_key, actor_id, class}
[:cyclium, :finding, :cleared]      — %{finding_key, actor_id, class}
[:cyclium, :finding, :expired]      — %{count}
[:cyclium, :finding, :escalated]    — %{finding_key, class, from, to}

Finding sweep events

[:cyclium, :finding_sweep, :completed] — %{duration_ms, expired_count, escalated_count}, meta: %{node}
[:cyclium, :finding_sweep, :failed]    — %{duration_ms}, meta: %{node, reason}

Work claims events

[:cyclium, :work_claims, :acquired]     — %{count, duration_ms}, meta: %{dedupe_key, owner_node}
[:cyclium, :work_claims, :steal]        — %{count, duration_ms}, meta: %{dedupe_key, owner_node}
[:cyclium, :work_claims, :busy]         — %{count, duration_ms}, meta: %{dedupe_key, owner_node}
[:cyclium, :work_claims, :renewed]      — %{count}, meta: %{dedupe_key, owner_node}
[:cyclium, :work_claims, :renew_failed] — %{count}, meta: %{dedupe_key, owner_node}
[:cyclium, :work_claims, :completed]    — %{count}, meta: %{dedupe_key, owner_node}
[:cyclium, :work_claims, :failed]       — %{count}, meta: %{dedupe_key, owner_node}

Phase events

[:cyclium, :phase, :changed]        — %{from, to, episode_id, actor_id}

Guardrail events

[:cyclium, :guardrail, :triggered]  — %{rule, episode_id, actor_id, detail}

Workflow events

[:cyclium, :workflow, :started]        — %{workflow_id, instance_id}
[:cyclium, :workflow, :step_started]   — %{workflow_id, instance_id, step_id, episode_id}
[:cyclium, :workflow, :step_completed] — %{workflow_id, instance_id, step_id}
[:cyclium, :workflow, :step_failed]    — %{workflow_id, instance_id, step_id}
[:cyclium, :workflow, :step_retried]   — %{workflow_id, instance_id, step_id, attempt}
[:cyclium, :workflow, :completed]      — %{workflow_id, instance_id}
[:cyclium, :workflow, :failed]         — %{workflow_id, instance_id, step_id}
[:cyclium, :workflow, :duplicate_blocked] — %{count}, meta: %{workflow_id, subject_value, owner_node}

Conversation events

[:cyclium, :conversation, :started]             — %{conversation_id, actor_id}
[:cyclium, :conversation, :claimed]              — %{conversation_id, principal_id}
[:cyclium, :conversation, :resolved]             — %{conversation_id, outcome}
[:cyclium, :conversation, :abandoned]            — %{conversation_id, reason}
[:cyclium, :conversation, :timed_out]            — %{conversation_id}
[:cyclium, :conversation, :awaiting_participant] — %{conversation_id, actor_id}

Usage

# Attach a simple logger for development
Cyclium.Telemetry.attach_default_logger()

# Or attach your own handler to specific events
:telemetry.attach("my-handler", [:cyclium, :output, :delivered], &MyHandler.handle/4, %{})