Service map and APM use the same trace input but different projections. Service map
pairs cross-service parent and child spans to build topology. APM builds bounded service,
transaction, dependency, error, and version aggregates.
How the map is built
As trace spans arrive, MoleSignal pairs each span with the parent span. Spans from different services form a call edge — parent service → child service — and the edge takes the child (callee) span’s duration and error status. Same-service parent/child spans are internal and aren’t drawn as edges. An edge is in the caller’s environment (deployment.environment.name, or
deployment.environment), else in the callee’s.
Edges are accumulated into one-minute buckets per service pair and flushed to storage in the
background, so the map reflects recent traffic within roughly half a minute.
In-memory vs storage mode
By default (intake mode) pairing happens in-memory on the node that accepts the spans — low
latency. In a multi-node deployment, spans for one call that land on different nodes can’t be paired
in memory, so the map may undercount those edges. The map never invents an edge.
To get a complete map across nodes, switch Settings → General → Service map data source to
storage mode. A single node then periodically rebuilds the graph from stored traces — seeing
every span regardless of the intake node — at the cost of a 1–2 minute delay. The setting is
stored in the database and takes effect at runtime; no restart needed.
Required trace data
The map needs traces with:- a
service.nameresource attribute on every span (OTLP exporters set this attribute), and - parent/child span relationships that cross service boundaries — i.e. a client span in one service whose child server span runs in another.
Topology
The topology endpoint aggregates a time window into nodes (services) and edges (calls):Raw service graph
For the underlying minute-by-minute edge snapshots — useful for charting a single dependency over time — query the service graph directly:from and to are microseconds since the Unix epoch. The optional service filter returns edges
where the selected service appears on either side of the call. Each row carries environment,
request_count, error_count, and p50_us / p95_us / p99_us for one service pair in one minute.
In the UI
- APM → Service map draws the services of an environment and the calls between them, with what they call and the topics they publish to and consume from. See the APM service map.
- Dependencies on a service’s APM page draws the service among what calls it and what it calls, as the APM map does, and lists the calls into it; a call opens in the same drawer.
- The Service graph tab of the Traces page draws the map of the traces a query matches.
The APM service map
APM → Service map joins the service graph with the APM projections, for the environment and the namespace chosen in its scope row:
A call is as thick as its traffic and in the colour of how it fails. Against the stretch of the same
length before, a call made only now reads New and one no longer made reads Gone, dashed, with
its node. Choosing a node lights what calls it and what it calls, and the slowest path down from
it: at each node the call with the highest P95. The card over the map lists the node’s calls; a call
opens in a drawer with its requests, errors, and latency over time and what was asked along it:
- to a service, the endpoints of the service called, as every caller asked them, and its error groups;
- to a database, a cache, or an outside endpoint, the operations of the call;
- through a topic, how long its messages waited: from the end of publishing to the start of consuming, read from the latest consumptions in the trace store (at most 200), each matched to the span its links name, else its parent.
Topology & service-graph API
Query the topology and raw service-graph endpoints over HTTP.
Application performance monitoring
Keep the service catalog and analyze service endpoints, dependencies, errors, and deployments.