Docs > Platform Observability > Getting Started with APM
Getting Started with APM
Overview
This guide introduces AppStatus APM and covers:
- Instrumentation: SDKs for Node, Python, Go, PHP, Java, .NET and Ruby
- OpenTelemetry: point an existing OTLP exporter at AppStatus, no SDK swap
- Service map built automatically from real traffic
- Latency percentiles, throughput and error rate per service and route
- One-click drill-down from a slow trace into its logs and errors
What is APM in AppStatus?
APM records how each request moves through your services. Every hop is timed, so a slow checkout is not just "slow" — you can see that 40ms was your API, 12ms was the database and 900ms was a third-party call.
You do not draw the service map or declare dependencies. Once traffic flows, AppStatus builds the map from the traces themselves and keeps it current as your architecture changes.
Key capabilities:
- Distributed tracing with a full waterfall view per request
- Golden metrics — rate, errors, duration and saturation — per service
- Automatic dependency discovery and service mapping
- Deploy markers on the timeline so a regression lines up with its release
- Trace IDs carried into logs and errors for one-click correlation
What you will see
What the service list looks like once traces arrive
Scroll the table sideways to see every column.
Click any service to open its route breakdown, then any route to open a trace waterfall.
Troubleshooting
The service does not appear after deploying
Check the ingest key is APM-scoped and the service name is set. A key scoped to a different signal is accepted at the edge but its data is not stored as traces. Traces usually appear within a minute of the first request.
Traces are incomplete — some hops are missing
Each service in the path needs its own instrumentation. A hop with no SDK shows as a gap. Confirm the trace header is being forwarded by any proxy or gateway in between.
p95 looks fine but users report slowness
Read p99 as well. A small share of very slow requests barely moves p95 but is exactly what users complain about. Filter by route and by region before concluding.
Operational Guidance
- Read the service map before the dashboards — it shows which dependency is actually degrading.
- Compare latency percentiles, not averages; p99 is where users notice.
- Traces carry the trace ID into logs and errors, so start at the trace and drill outward.
- Deploy markers on the timeline tell you whether a release caused the change.
Step-by-Step Setup
Getting APM running is two decisions and one deploy: which key the service uses, and how it reports. Once traffic flows, the service map, latency percentiles and error rate build themselves — there is nothing to draw or declare.
Before you start
- An application you can deploy a code or config change to
- Permission to create an ingest key in your workspace
- 1
Create an ingest key scoped to APM
Open Ingest Keys and create a key scoped to APM for the environment you are setting up. The key value is shown once — copy it into your secret manager now, not into source control.
WhereIngest Keys → Create keyTipOne scope per key. A key reused across signals turns a single leak into full ingest access.
- 2
Add instrumentation
Install the SDK for your language and initialise it as early as possible in your entry point. If you already run OpenTelemetry, skip the SDK entirely and point your existing OTLP exporter at the AppStatus endpoint instead — your instrumentation does not change.
WhereAPM → Add service → pick your languageTipInitialise before your framework and database clients load, or the first calls of each request go untraced.
- 3
Set service name and environment
Give the service a stable name — the deployable unit, not the hostname — and set the environment. Traces group by these two values, so a rename splits your history and a missing environment mixes staging into production baselines.
WhereSDK configuration - 4
Deploy and confirm
Deploy, then send a handful of requests. Open the APM service list and confirm the service appears with live throughput. First data usually lands within a minute.
WhereAPM → Services - 5
Walk one trace end to end
Open the slowest recent trace and read the waterfall. Every hop your request makes should be visible; a gap means a service in the path is not yet instrumented, or a proxy is dropping the trace header.
WhereAPM → Services → pick a service → TracesTipDo this once now. Discovering a missing hop during an incident is a bad time to find out.
Configuration Options
Every option you can set, what each choice means, and what to pick. Use this as a reference while you fill in the form.
Instrumentation options
Set these in the SDK or exporter configuration.
| Field | Options | What it does | Recommended |
|---|---|---|---|
| Service name | Any stable string | Groups all traces from one deployable unit. | The service name, stable across releases. Never the hostname. |
| Environment | production, staging, custom | Separates traffic so baselines stay meaningful. | Always set it. Unset traces are hard to filter later. |
| Sample rate | 0–100% | Share of requests recorded as traces. | Start at 100% while traffic is low; reduce as volume grows. |
| Transport | AppStatus SDK or OTLP | How spans reach the platform. | OTLP if you already run OpenTelemetry; the SDK otherwise. |
Feature Reference
Every feature, where to find it in the app, and what it does. Use this when you know what you want to do but not where it lives.
| Feature | Where in app | Description |
|---|---|---|
| Service map | APM → Services → Map | Dependencies discovered from real traffic, kept current automatically. |
| Trace waterfall | APM → Traces → open a trace | Every hop timed, with the slow one visible at a glance. |
| Route breakdown | APM → Services → pick a service | Throughput, latency percentiles and error rate per route. |
| Deploy markers | APM timeline | Releases marked on the chart so regressions line up with their cause. |
Next Steps
Continue building your monitoring stack:
