Follow the evidence across infrastructure, autonomous systems, networks, and financial workflows.

Self-hosted connected observability with explicit trust, durability, and causality boundaries.

Current status · Quickstart · Architecture · Validation · Brand

Sennet reconstructs one event across application traces, logs, metrics, agent executions, network observations, and financial lifecycle records. It keeps observed parents, span links, domain identifiers, event time, receive time, queue time, and processing time distinct—because correlation is not causality.

Important

Sennet is a substantial working foundation, not evidence of Datadog-scale capacity, high availability, regulatory compliance, or production readiness. The shipped Compose topology is a single-replica evaluation environment. Measure your own deployment before making capacity or availability claims.

What you can investigate

Surface	Evidence available now	Current boundary
Infrastructure and applications	Traces, logs, metrics, service dependencies, waterfalls	Large-graph and long-term rollup work remains
Autonomous systems	Runs, handoffs, retries, loops, token and cost provenance, critical path	Evaluation pipelines and policy management remain
Financial operations	Exact decimal values, sequence gaps, invalid transitions, lifecycle inspection	Operational evidence only; Sennet is not a ledger
Network telemetry	Linux traffic counters and bounded flow observations	Kernel-specific probes remain opt-in and require validation
Telemetry pipeline	Admission, Kafka durability, ClickHouse analytics, lag and partial states	Distributed HA and sustained-load results are not established
Investigation workspace	Shared scope, alternate visualizations, saved views, dashboards, monitors	Some control-plane management remains backend-only

The interface never substitutes demo records into a workspace. Marketing examples use a deterministic fixture and are visibly labelled Demo.

See the system, not another chart

The workspace keeps query, time range, timezone, environment, service, tenant, and selection context stable while the representation changes.

• Time series, comparison windows, percentiles, annotations, and distributions
• Pipeline, tunnel, topology, and evidence-backed dependency views
• Nonlinear transmission timeline for services, agents, tools, queues, network, and financial state
• Agent DAGs with handoffs, parallel branches, retries, cancellations, cost, and critical path
• Financial lifecycle inspection with exact values, delay, duplicates, sequence gaps, and affected dependencies
• Saved dashboards with backend persistence, immutable versions, synchronized variables, and explicit unavailable states

How evidence moves

OTLP / domain events / agents
             │
             ▼
     authenticated gateway
       validation + scope
             │
       ┌─────┴──────────────┐
       ▼                    ▼
 local durable store    Kafka admission
   (development)             │
                             ▼
                    storage consumer
                             │
                             ▼
                    ClickHouse analytics
                             │
             ┌───────────────┴──────────────┐
             ▼                              ▼
      query/control API              investigation UI

PostgreSQL stores identity and control metadata in the streaming topology. Kafka provides durable ingestion. Consumers commit offsets only after analytics persistence, and browser queries remain tenant- and time-bounded.

Read the architecture for trust boundaries, acknowledgement semantics, query limits, and remaining work.

Run locally

Requirements

• Go 1.24 or newer
• Node.js 22 or newer
• Python 3, only if you want to send the deterministic evaluation fixture

1. Start the backend

Create a development bootstrap credential. Use sk_ followed by at least 32 random hexadecimal characters; never commit it.

$env:INIT_API_KEY = 'sk_' + [guid]::NewGuid().ToString('N') + [guid]::NewGuid().ToString('N')
$env:SENNET_AUTH_MODE = 'development'
$env:SENNET_DEVELOPMENT_SESSION_TOKEN = 'replace-with-a-local-random-token'
$env:SENNET_DEVELOPMENT_TENANT = 'local'
cd backend
go run .

2. Start the product workspace

In a second terminal:

$env:VITE_SENNET_DEVELOPMENT_SESSION_TOKEN = $env:SENNET_DEVELOPMENT_SESSION_TOKEN
$env:VITE_SENNET_DEVELOPMENT_TENANT = $env:SENNET_DEVELOPMENT_TENANT
cd web
npm ci
npm run dev

Open http://localhost:5173. The development server proxies API requests to localhost:8080. Development session variables are ignored by production builds.

Create an ingestion-only key in the workspace for collectors. Use a reader key for read-only humans.

3. Send optional evaluation data

$env:SENNET_API_KEY = 'sk_your_ingestion_key'
python examples/send_fixture.py

The fixture is deterministic, documented, and explicitly identified as evaluation data.

Streaming evaluation stack

Set random INIT_API_KEY, SENNET_POSTGRES_PASSWORD, and SENNET_CLICKHOUSE_PASSWORD values, then run:

docker compose -f deploy/compose.yaml up --build --wait

Open http://localhost:8088. Data persists in Docker volumes. PostgreSQL stores identities and configuration, Kafka handles durable admission, and the consumer batches observations into ClickHouse.

Before a production deployment, configure TLS, Kafka replication and minimum ISR, replicated ClickHouse tables, backups, tenant budgets, and an authenticated ingress. SENNET_ENV=production rejects startup unless PostgreSQL, Kafka, and ClickHouse are configured.

Collect signals

• OTLP/HTTP — /v1/traces, /v1/logs, and /v1/metrics; JSON or protobuf; gzip supported.
• Domain events — POST /api/events; 1–1,000 records; stable IDs required for replay.
• OpenTelemetry Collector — deploy/otel-collector.yaml includes a persistent exporter queue.
• Python SDK — sdk/python/sennet.py supports nested spans, context propagation, exact decimal events, and a disk outbox.
• Linux network collector — durable bounded spooling, real counters, measured rates, and explicit unsupported states.

# /etc/sennet/config.yaml
api_key: "sk_REPLACE_WITH_INGEST_KEY"
server_url: "https://your-sennet-server.example"
interface: "eth0"
heartbeat_interval_secs: 30
state_dir: "/var/lib/sennet"
log_level: "info"

Windows does not support local eBPF collection. Optional layout-dependent probes are disabled unless SENNET_EXPERIMENTAL_KERNEL_PROBES=true; enabling them requires validation against the target kernel.

Repository map

Path	Purpose
backend/	Go ingestion, identity, control, query, and persistence services
web/	React consumer site, documentation, and investigation workspace
agent/	Rust Linux network collector and terminal interface
sdk/	Application instrumentation and domain-event helpers
deploy/	Compose, Kubernetes, collector, and deployment configuration
dashboards/	Operational dashboard definitions
examples/	Deterministic evaluation fixtures and integrations
docs/	Architecture, contracts, audits, runbooks, brand, and release evidence

Verify the repository

cd backend && go test ./...
cd ../agent && cargo test --locked
cd ../web && npm run lint && npm run build && npm run test:browser

The browser suite covers responsive layouts, reduced motion, keyboard operation, route restoration, protected-route loading boundaries, error states, and horizontal overflow. Executed evidence is recorded in docs/audit-validation.md and docs/release-evidence.

Current release boundary

Local backend, SDK, SQLite evaluation, and the product interface are locally testable. The distributed evaluation deployment still requires environment-specific Compose execution, failure testing, restore drills, and sustained-load measurement. Production remains blocked on the gates in implementation status.

Legacy data and keys are not automatically assigned to a new tenant. Keep old databases offline until ownership mapping and secret migration are explicit.

---

Observe the whole system. Follow only the evidence it contains.