Product

One observability data plane for every signal.

Accept 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 APM overview with throughput, error rate, latency, service health, and high-impact dependencies — APM

intake protocols: 9
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 shipped operator surfaces: APM service health, dashboards, SQL log search, PromQL metrics, traces, browser sessions, Web Vitals, profiling flame graphs, alerting, synthetic monitoring, customer status pages, data pipelines, and governed AI investigations.

Services + transactions + dependencies

See application health before opening a single trace.

Compare throughput, error rate, tail latency, deployments, dependencies, and top backend errors across real services.

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.

Understand application health before the next incident.

Turn OpenTelemetry traces into service-level throughput, error, and latency views. Compare transactions, dependencies, errors, and deployments, then open the representative request without rebuilding context.

Keep the production story on one shared canvas.

Compose operational views from the telemetry already in MoleSignal. Organize dashboards by folder and tags, reuse variables, import JSON, and move from any panel into the underlying investigation.

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 intake path, or use anomaly detectors—then route incidents through policies, rotations, and the channels your team already uses.

Test the customer journey before customers report it.

Run active protocol and browser checks from the Standalone embedded runner or your own private Probe locations. Test every draft, publish a verified revision, and keep schedule, state, and execution evidence connected.

Turn operational truth into customer communication.

Operate public or private status pages without mixing the event archive into the daily workspace. Manage components, incidents, maintenance, subscribers, domains, access, and publication automation from seven focused areas.

Shape telemetry before it becomes storage cost.

Connect real sources, define governed streams, and normalize, enrich, redact, encrypt, or route data before it lands. Monitor every log, metric, and trace pipeline with run history and health state.

Ask the platform. Inspect the evidence. Govern the action.

Use Mole Agent to investigate anomalies across telemetry and operational context. Turn repeatable work into automations, require approval for sensitive actions, and retain a record of every execution.

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
Intake protocols
Real-time alerts
Multi-tenancy

Solutions

Nine 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.

Find the service, request, or dependency consuming the latency budget.

Turn OpenTelemetry traces into service-level throughput, error, and latency views, then continue from a regression to the representative transaction, dependency, deployment, or hot function.

See the user journey before the backend failure.

Measure real browser performance, find the affected session, replay the sequence of actions, and follow the frontend request into the responsible backend trace without losing time or user context.

Turn Kubernetes telemetry into an investigation path, not another silo.

Onboard cluster logs through the guided Fluent Bit path, receive application metrics and traces through existing collectors, normalize workload context before storage, and move from a symptom to the responsible service or event.

Roll out OpenTelemetry without turning adoption into a flag day.

Start with one service or Collector, keep current compatible paths while teams migrate, validate logs, metrics, and traces on the same data plane, and standardize resource attributes before expanding coverage.

Accelerate the investigation without hiding the evidence or the action.

Ask about a service, anomaly, trace, alert, or on-call owner in plain language, let governed tools gather the relevant telemetry, review the supporting evidence, and require approval before sensitive operations execute.

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, intake, querier, compactor, alert-manager, and connector roles.

Self-host free See all integrations