---
title: 'OpenTelemetry Synthetic Monitoring'
description: 'Synthetic checks that emit rich OTLP insight packs: anomaly scores, third-party attribution, screenshot URLs, and W3C traceparent into your ClickStack, Dash0, or Grafana backend.'
canonical_url: 'https://yorkermonitoring.com/features/opentelemetry'
---

# Synthetic intelligence that speaks OTel natively

And enriches every tool in your stack.

The missing OTel data source.

Every browser check emits a rich OTLP insight pack: anomaly scores, third-party attribution, screenshot URLs, and W3C traceparent headers. Not metrics bolted onto a silo. Structured intelligence that flows into your existing backend.

[Start Free](/sign-up) | [Read Docs](/docs)

```
# otlp signals → your backend

# synthetics.check.run span
synthetics.check.name           "Checkout Flow"
synthetics.check.type           browser
synthetics.location.name        London, UK
synthetics.tls.days_until_expiry  42
synthetics.tls.fingerprint_sha256 a1b2c3d4...
synthetics.response_time_ms       4023
synthetics.third_party.count            12
synthetics.third_party.total_bytes      847293
synthetics.third_party.domains          [cdn.tagmanager.net, ...]
synthetics.screenshot.url         https://screenshots.yorkermonitoring.com/...

# OTLP top-level field (ClickHouse TraceId column, not a span attribute)
TraceId                         4bf92f3577b34da6a3ce929d0e0e4736

# synthetics.check.completed log event (fires every run;
# anomaly attrs below attached on this anomalous example)
synthetics.is_anomalous           true
synthetics.anomaly.deviation_sigma  2.8
synthetics.anomaly.baseline_value   1842

# synthetics.correlation.detected log event (browser checks only;
# fires when 2+ browser checks co-fail within a 5-min window sharing a domain)
synthetics.correlation.affected_count       4
synthetics.correlation.shared_dependency    cdn.tagmanager.net
synthetics.correlation.affected_monitors    [chk_checkout, chk_signup, ...]
```

## How it works

### 01. Check runs from a global location

Your HTTP or browser check executes from one of 14 hosted locations, or a private location behind your firewall. Real browser, real network, real TLS handshake.

### 02. Anomaly scores and attribution computed

Anomaly deviations calculated against per-metric, per-location, per-hour-of-day baselines. Third-party requests classified: count, total bytes, and domain list emitted as span attributes. Correlation signals detected for the alerting UI.

### 03. Full OTLP insight pack emitted

Metrics, traces, and logs emitted in parallel to your backend with anomaly scores, third-party attribution, screenshot URLs, and W3C traceparent already attached.

## What's in every insight pack

Every check run, HTTP or browser, emits the same six categories of structured intelligence into your OTel backend. No configuration required.

- **Anomaly scores.** Deviation in σ from a 14-day rolling baseline, calculated per metric, per location, and per hour of day.
- **Dependency attribution.** Third-party domains classified, payload bytes tracked, latency measured, and compared across your monitor portfolio.
- **Cross-monitor correlation.** When two or more browser monitors fail within a five-minute window and observe the same third-party dependency, Yorker emits a synthetics.correlation.detected log event with the affected check IDs and shared domain. De-duplicated by team, shared dependency, and the exact affected-monitor set: one event per distinct correlation slice, not one per failing check run. Browser checks only: the signal is derived from network-summary data the browser executor captures.
- **Screenshot URLs in spans.** Screenshot stored, URL embedded directly in the OTel span. Pull up visual evidence from inside Grafana, your runbook, or a PagerDuty alert.
- **W3C trace propagation.** traceparent injected into browser check HTTP requests. Your backend picks it up, so synthetic check and backend trace become one distributed trace.
- **TLS context.** Certificate expiry, issuer chain, fingerprint, and TLS handshake duration emitted as span attributes on every HTTPS check.

### Emitted on every browser check run

| Attribute | Value |
| --- | --- |
| `synthetics.is_anomalous` | true |
| `synthetics.anomaly.deviation_sigma` | 2.8 |
| `synthetics.anomaly.baseline_value` | 1842 |
| `synthetics.third_party.count` | 4 |
| `synthetics.third_party.total_bytes` | 847293 |
| `synthetics.third_party.domains` | [cdn.tagmanager.net, ...] |
| `synthetics.tls.days_until_expiry` | 42 |
| `synthetics.tls.fingerprint_sha256` | a1b2c3d4... |
| `synthetics.screenshot.url` | https://screenshots.yorkermonitoring.com/... |
| `TraceId (column, not attribute)` | 4bf92f35... |

## Works with your existing stack

Yorker emits standard OTLP signals. No proprietary format, no vendor lock-in. Configure your OTLP endpoint once: synthetic intelligence lands alongside your infrastructure telemetry, in the same backend, in the same dashboards.

First-class integration with the ClickStack ecosystem: ClickHouse + HyperDX. Connect any OTLP-compatible backend in under a minute.

| Backend | Note |
| --- | --- |
| ClickStack | First-class |
| Dash0 | OTLP/HTTP |
| Grafana Cloud | OTLP/gRPC |
| Datadog | OTLP ingest |
| Honeycomb | OTLP/HTTP |
| Any OTLP endpoint | Standard spec |

## Trace propagation

W3C `traceparent` injected into every browser check HTTP request. Your backend instruments pick it up, so the synthetic check and the backend trace become one distributed trace in your observability backend.

No separate synthetic trace tree. No context-switching. One trace, from the Playwright browser to the database query, with the synthetic check as the root span.

```
# w3c trace propagation

# Browser check emits root span
trace_id  4bf92f3577b34da6a3ce929d0e0e4736
span_id   a3ce929d0e0e4736
service  synthetics.browser

# Request to your API carries traceparent
traceparent 00-4bf92f35...-a3ce929d-01

# Your backend continues the trace
trace_id  4bf92f3577b34da6a3ce929d0e0e4736
parent_id a3ce929d0e0e4736
service  your-api-service
```

## Unlike basic OTel bolt-ons

- Checkly and Datadog Synthetics emit basic metrics to OTel. Yorker emits anomaly-scored spans with third-party attribution, screenshot URLs, full timing breakdowns, and W3C traceparent already attached.
- No separate dashboard to context-switch to. Your synthetic intelligence lands in the same backend as your infrastructure telemetry, queryable alongside APM, logs, and infrastructure metrics.
- W3C traceparent propagation links synthetic checks into your existing distributed traces, not a separate trace tree. One trace from browser to database.

## Related features

### Browser Monitoring

Playwright checks with third-party dependency attribution and filmstrip evidence.

[/features/browser-monitoring](/features/browser-monitoring)

### Alerting

Multi-location correlation and alert triage with full OTel context.

[/features/alerting](/features/alerting)

### Private Locations

The same OTel intelligence layer running behind your firewall, at half the hosted rate.

[/features/private-locations](/features/private-locations)

## Frequently asked questions

### What is OTel-native synthetic monitoring?

OTel-native means Yorker emits standard OpenTelemetry signals (traces, metrics, logs) rather than storing results in a proprietary silo. Every check run produces an OTLP insight pack (anomaly scores, third-party attribution, screenshot URLs, and W3C traceparent) that lands in your own OTel backend alongside your infrastructure telemetry. No separate dashboard, no proprietary API: just OTLP.

### How does Yorker correlate synthetic checks with backend traces?

Browser checks inject a W3C traceparent header into every outbound HTTP request. Your backend instrumentation picks up that header and continues the same trace, so the synthetic check and your backend spans share one trace ID. In ClickHouse or any OTel-compatible backend you can query them together: the synthetic check is the root span.

### Which OTel backends does Yorker support?

Any backend that accepts standard OTLP/HTTP. Yorker has first-class integration with ClickStack (ClickHouse + HyperDX) and works with Dash0, Grafana Cloud, Datadog OTLP ingest, Honeycomb, and any other OTLP-compatible endpoint. You configure one OTLP endpoint URL and an API key in the Yorker dashboard; no per-backend SDK or agent is required.

### What is an OTLP insight pack?

An insight pack is the set of enriched OTLP signals emitted for each check run: a trace span with TLS context, screenshot URL, and W3C traceparent; individual gauge metrics for each timing phase (DNS, TCP, TLS, TTFB); a synthetics.check.completed log event with anomaly deviation scores; and, when applicable, a synthetics.correlation.detected log event listing co-failing monitors and the shared third-party dependency. All fields use standard OTLP attribute naming.

### Does synthetic telemetry bypass Yorker before reaching my backend?

No. Check telemetry flows through Yorker's platform where anomaly scoring, dependency attribution, and correlation detection are computed. The enriched OTLP signals are then forwarded to your backend as standard OTLP. The value is the enrichment and the portability: you receive standard signals with computed intelligence attached, not raw timings.

## Put your first check live in one command.

Free tier includes 10,000 HTTP + MCP checks and 1,500 browser checks per month. No credit card required.

```
npx @yorker/cli init
```

[Start Free](/sign-up) | [Read Docs](/docs)