> ## Documentation Index
> Fetch the complete documentation index at: https://docs.honeycomb.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Connect Honeycomb and Embrace

> Connect Honeycomb and Embrace to correlate backend traces with mobile and web user sessions.

## Overview

Embrace is a mobile and web observability platform that captures user session data, including network requests, ANRs, hangs, crashes, Core Web Vitals, and rage taps.
Honeycomb and Embrace together give your engineering teams complete visibility across the full request path, from the user's device to your backend services and back.

The integration connects the two using standard OpenTelemetry trace context, so the full request path appears in a single Honeycomb trace view.
When something goes wrong, you can move between backend traces and user session context.

## How it works

The integration uses two mechanisms to connect Honeycomb and Embrace: network spans forwarding and W3C trace context propagation.

### Network spans forwarding

Embrace automatically attaches a W3C `traceparent` header to every network request your app makes.
The Embrace SDK forwards a span representing that network call directly to Honeycomb via OTLP, using an exporter configured in your SDK setup.

```mermaid actions={false} theme={}
flowchart LR
    subgraph Client["Client"]
        mobile["Mobile App"]
        web["Web App"]
    end

    subgraph SDK["Embrace SDK"]
        embrace["Embrace"]
        otel["OpenTelemetry"]
        embrace --- otel
    end

    subgraph Platform["Embrace Platform"]
        dashboard["Embrace Dashboard"]
    end

    honeycomb["Honeycomb"]

    mobile --> SDK
    web --> SDK
    SDK -->|"Frontend\nTelemetry\n(OTLP)"| Platform
    SDK -->|"Network\nSpans\n(OTLP)"| honeycomb
    Platform -->|"Metrics\n(OTLP)"| honeycomb
```

Each span carries both standard OpenTelemetry attributes and Embrace-specific attributes prefixed with `emb.`.

Your backend services pick up the incoming `traceparent` header and continue the trace using their existing OpenTelemetry instrumentation.
Because the client span and the backend spans share the same trace ID, Honeycomb stitches them together automatically in the trace view.
The forwarded client span appears at the top of the waterfall with the backend service spans below it.

### Embrace attributes in Honeycomb

Every span Embrace forwards to Honeycomb includes mobile and web context that your backend instrumentation cannot provide on its own.
These attributes include:

* `emb.app_version`: Version of the app that made the request
* `emb.device_id`: ID of the device that made the request
* `emb.device_model`: Device model
* `emb.os_version`: Operating system version
* `emb.country_iso`: Country where the request originated
* `emb.dashboard_session`: Direct link to the user's session in Embrace

Because these attributes arrive as standard span attributes, you can use them in Honeycomb queries, BubbleUp analysis, and trigger conditions just like any other dimension.

### Session metrics

When you configure metrics forwarding, Embrace also sends session and network metrics to Honeycomb:

* `exceptions`: Unhandled exception count per session
* `logcount`: Log event count per session
* `network.request`: Total network requests
* `network.successful.request`: Successful network requests
* `network.successful.request.duration.total`: Total duration of successful network requests
* `root.span.count`: Root span count per session
* `root.span.duration.total`: Total duration of root spans
* `session.count`: Total session count
* `session.duration.total`: Total session duration
* `span.count`: Total span count per session
* `span.duration.total`: Total span duration
* `user.flow.count`: User flow count per session

### Session deep links

When a forwarded span includes `emb.dashboard_session`, Honeycomb renders it as a clickable link in the span detail view.
Selecting it opens the exact user session in Embrace, with the network entry for that request already selected in the session timeline.

### BubbleUp on mobile dimensions

Because Embrace attributes are first-class span dimensions in Honeycomb, BubbleUp can use them to surface patterns in your trace data.
If a latency spike or error rate is concentrated in a specific app version, device model, or OS version, BubbleUp will identify it alongside your backend dimensions.

## What you can do

Once you have [configured the integration](/integrations/embrace/configure/), you can:

* Pivot from a backend trace to originating user session in Embrace
* Use BubbleUp to identify whether a latency issue is concentrated in a specific app version, device, or OS
* Query Embrace attributes alongside your backend dimensions in any Honeycomb query
* Confirm user impact before escalating a backend incident
* Monitor Embrace session metrics, including crash rates, ANR rates, session counts, and network request performance, alongside your backend trace data

For step-by-step workflows, visit our use case guides:

* [Investigate backend latency](/integrations/embrace/use-cases/investigate-backend-latency)
* [Diagnose mobile ANRs and hangs](/integrations/embrace/use-cases/diagnose-mobile-anrs)
* [Investigate with Embrace and Honeycomb MCP](/integrations/embrace/use-cases/investigate-with-mcp)