Product

One observability data plane for every signal.

Ingest the formats you already run, keep telemetry on your object storage, query columnar signals with SQL or PromQL, and investigate from browser session or alert to backend request, hot function, or event without leaving the product.

Self-host free Read the architecture

molesignal metrics explorer showing a PromQL query, time series, labels, and cardinality — Metrics

ingest protocols: 10
query surfaces: SQL + PromQL
alert rule kinds: 3
scalable runtime roles: 6

Real product, not a moodboard

From raw telemetry to a resolved incident.

Explore the operator surfaces already in the product: PromQL metrics, service maps, profiling flame graphs, browser sessions, Web Vitals, dashboards, SQL log search, alerts, and a keyboard-first investigation flow.

PromQL + cardinality context

Query the trend. See the shape behind it.

Explore series, top labels, percentiles, cardinality, and related metrics in the same workspace.

Choose the operator surface you need.

The pages below describe shipped workflows and their current limits, not a future product catalog.

Four signal families. One operational context.

Keep logs, metrics, traces, and continuous profiles under one tenant and time model. Columnar telemetry shares one query plane while lossless pprof archives stay portable on object storage.

Search every event without losing the incident.

Use structured fields, SQL, distributions, and full-text pruning while trace and time context stay ready for the next drill-down.

See the trend and the telemetry behind it.

Query Prometheus-shaped metrics with PromQL, inspect labels and cardinality, and move from a spike to the responsible service and traces.

Move from service topology to the failing span.

Explore service health, RED metrics, latency distributions, error-first traces, and complete span waterfalls in one workflow.

See what the code was doing when the request slowed down.

Capture CPU, memory, goroutine, and lock profiles across services. Explore flame graphs, call trees, and top functions, then move between a hot frame and its correlated trace or span.

See the user journey that happened before the backend failed.

Connect browser sessions, actions, errors, Web Vitals, and frontend requests to the same trace and time context used by backend telemetry. Reproduce the journey in Session Replay, then continue into the responsible backend span.

Keep the incident together as the question changes.

Move metric → trace → profile or log → host and back while the investigation stack preserves each frame, time anchor, and entity filter.

Detect on the right path. Route with context.

Evaluate SQL on a schedule, match events in the ingest path, or use anomaly detectors—then route incidents through policies, rotations, and the channels your team already uses.

Under the interface

A shared data plane changes the workflow.

Logs, metrics, and traces share physical storage, time indexing, tenant enforcement, and a vectorized query engine. Profile metadata joins the same tenant and time plane while lossless pprof archives remain portable on object storage.

proof / shipped

Query engine

A vectorized query engine plans SQL, PromQL, and VRL against the columnar store. The planner does multi-tenant org-rewrite, so tenant isolation lives at the query layer rather than at the deployment layer.

Three signals, one storage
Ingest protocols
Real-time alerts
Multi-tenancy

Solutions

Four paths into the same platform.

Each solution page starts from an operator workflow and links back to the exact capabilities that make it possible.

Reduce the time spent reconstructing the incident.

Give operators one continuous path from symptom to service, request, span, hot function, and event instead of disconnected tools and copied IDs.

Control the storage model before cutting visibility.

Keep telemetry on object storage you choose, use columnar pruning and caches to reduce reads, and evaluate cost with visible assumptions.

Keep open source. Remove the three-store tax.

Accept the protocols already connected to Loki, Elasticsearch, Prometheus, and OpenTelemetry while moving the durable data to one platform.

Give every team context without deploying a stack per team.

Use planner-level organization isolation, quotas, audit, roles, and scalable runtime components to serve multiple teams from one telemetry plane.

pre-1.0 · building in the open

Start with the standalone profile.

The same binary can run as one local process or split into router, ingester, querier, compactor, alert-manager, and connector roles.

Self-host free See all integrations