Back
    Enterprise · Observability

    Wire it into the stack you already run.

    Metrics, traces, structured logs and an audit stream — on open, standard endpoints. Point your Prometheus, your OTLP collector and your SIEM at Pulse. It exposes; you scrape. It never phones home.

    Prometheus /metricsOpenTelemetry OTLPAudit SSE → SIEMPer-event time-travel

    On your perimeter

    Pulse never opens an outbound connection to a third-party observability service. Every signal is exposed on an endpoint inside your network; your collectors connect in, and you decide what leaves your egress. No embedded OTLP destination, no vendor lock-in, no telemetry back to us.

    Four signals, standard shapes

    Everything you'd instrument yourself — already emitted.

    Each signal speaks the format your tools already ingest. No adapter to write, no proprietary agent to install.

    Metrics

    GET /metrics

    Engine throughput, consumer lag, Raft replication, JVM, agents & MCP tools — in Prometheus text format.

    → Prometheus · Grafana · VictoriaMetrics

    Traces

    OTLP · W3C context

    Spans on the webhook, consensus and MCP paths, plus auto-instrumented HTTP / Postgres / JDBC. Export where you like.

    → Tempo · Jaeger · Datadog APM

    Structured logs

    stdout · correlation-tagged

    SLF4J / Logback lines carry trace & span IDs when the OTel agent is attached — ship them with the agent you already run.

    → Loki · Vector · Fluent Bit · Filebeat

    Audit stream

    GET /api/audit/stream

    A long-lived SSE feed of every audit row — who did what, when — with bearer tokens and gap-free reconnect.

    → Splunk · Elastic SIEM · Wazuh · Chronicle

    The endpoints, for real

    Scrape it, trace it, stream it.

    The actual calls an operator makes. Copy them against a running Pulse.

    Format Prometheus textPort 8080Auth: none (bind to metrics network)
    # Point your Prometheus scrape_config at it — or curl it directly
curl http://pulse:8080/metrics

    Sample output

    # HELP streamflow_engine_events_total Events ingested
streamflow_engine_events_total{node="node-1"} 4821573
streamflow_engine_append_latency_seconds{quantile="0.99"} 0.0004
streamflow_consumer_lag{group="orders",topic="orders"} 12
streamflow_raft_replication_ratio{node="node-1"} 1.0
pulse_agent_events_processed_total{agent="fraud-scorer"} 98120
pulse_mcp_tool_calls_total{tool="slack.post"} 431
jvm_memory_used_bytes{area="heap"} 318767104

    Per-event time-travel

    Replay one event's entire journey — deterministically.

    Beyond aggregate dashboards: pick a single event and walk its full path across sources, stages and sinks. Pulse records each hop's trajectory and can re-run it byte-for-byte in a mocked engine — the same input yields the same output, twice.

    source

    webhook.ingest

    +0.0 ms

    stage · rule

    fraud-score

    +1.2 ms

    stage · llm

    triage-router

    +284 ms

    stage · mcp

    slack.post

    +91 ms

    sink

    jdbc.orders

    +3.4 ms

    Deterministic replay is tested in CI. The replay engine re-runs a captured event with mocked I/O and asserts the output is byte-identical across two runs — so a "why did this event do that?" investigation is reproducible, not guesswork. Pull one event's trajectory at GET /api/pulse/trajectory/{eventId}.

    Dashboards in one command

    A Grafana board that's already wired.

    Don't want to build panels from scratch? A Prometheus + Grafana stack with a provisioned StreamFlow dashboard ships in the repo.

    Metric families

    Engine throughput · append latency · disk; consumer lag; Raft replication ratio; JVM; Agents; MCP tools; agent-graph spans.

    Grafana dashboard

    9 panels, provisioned automatically, with visual thresholds.

    Alerts

    Pre-configured rules; route to Slack / PagerDuty via Alertmanager.

    Spin up the monitoring stack

    # Prometheus + Grafana, dashboard auto-provisioned
docker compose -f deploy/monitoring/compose.yml up -d

# Grafana → http://localhost:3000  (dashboard already there)
# Raw metrics → http://pulse:8080/metrics
    PrometheusGrafanaTempoJaegerLokiAlertmanagerSplunkDatadogElasticWazuh

    Honest boundaries.

    Tracing is opt-in.

    Pulse has zero compile-time dependency on OpenTelemetry — spans become real only when you attach the standard agent, and are a guaranteed no-op (single volatile read, zero allocation) when you don't. That keeps the single-binary on-prem install lean.

    Nothing leaves your perimeter by default.

    You choose the OTLP endpoint and the SIEM destination; Pulse never initiates an outbound telemetry connection.

    Logs are correlation-tagged, not reformatted.

    They carry trace/span IDs when the agent is attached; ship them with the log agent you already run.

    ◆ Enterprise

    Your dashboards. Your SIEM. Your call.

    Open endpoints, standard formats, no phone-home. Plug Pulse into the observability stack you already trust — in an afternoon, not a quarter.

    Read the observability guideSee a sample dashboard