Add Latitude as an observability provider (OTLP, open-source, self-hostable)

[guillemwilly]

Summary

Add Latitude as a documented observability provider for Flue, alongside OpenTelemetry, Braintrust, and Sentry. Latitude is an open-source LLM observability and evaluation platform that ingests OpenTelemetry traces, so it fits Flue's existing @flue/opentelemetry adapter with no new package required.

Background & Motivation

Flue already converts its observe(...) event stream into OpenTelemetry spans through @flue/opentelemetry, but the user still has to pick and wire up a backend. The "Choose an observability provider" table currently lists OpenTelemetry, Braintrust, and Sentry.

Latitude is a natural fit for Flue users who want agent-focused traces plus evaluations:

• It ingests standard OTLP, so it works on top of the existing @flue/opentelemetry adapter. Users only add an OTLP exporter pointed at https://ingest.latitude.so.
• It is open source and can be fully self-hosted, which matches Flue's runtime-agnostic, self-owned-infrastructure posture.
• It aggregates token usage, cost, and latency at every level of the agent → operation → model-turn → tool hierarchy, and adds offline and live evaluations on top of traces.

Latitude recently shipped instrumentation across many agent frameworks (Agno, Google ADK, OpenAI Agents, LlamaIndex, and others). Documenting the Flue path would let Flue users adopt it without rediscovering the OTLP wiring themselves.

Goals

• Give Flue users a documented, copy-pasteable path to send Flue traces to Latitude.
• Reuse the existing @flue/opentelemetry adapter rather than introducing a new dependency or a bespoke observe(...) bridge.
• Match the structure, tone, and data-handling guidance of the existing OpenTelemetry and Braintrust integration pages.
• Add a row to the "Choose an observability provider" comparison table and a nav entry under Ecosystem → Tooling.

Example

The integration is the existing OpenTelemetry adapter with an OTLP exporter aimed at Latitude:

// src/app.ts (abridged)
import { NodeSDK } from '@opentelemetry/sdk-node';
import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
import { createOpenTelemetryObserver } from '@flue/opentelemetry';
import { observe } from '@flue/runtime';

const sdk = new NodeSDK({
  traceExporter: new OTLPTraceExporter({
    url: 'https://ingest.latitude.so/v1/traces',
    headers: {
      Authorization: `Bearer ${process.env.LATITUDE_API_KEY}`,
      'X-Latitude-Project': process.env.LATITUDE_PROJECT ?? '',
    },
  }),
});

sdk.start();

observe(createOpenTelemetryObserver());

Proposed changes (drafted, ready to drop in)

If this is accepted, here is a draft that follows the existing patterns. Happy to adjust to your house style (for example, this draft avoids em dashes by request).

1. New page: apps/docs/src/content/docs/ecosystem/tooling/latitude.md

2. Nav entry in apps/docs/src/lib/docs-navigation.ts, Ecosystem → Tooling group: { title: 'Latitude', slug: 'ecosystem/tooling/latitude' }

3. New row in the "Choose an observability provider" table in apps/docs/src/content/docs/guide/observability.md:

   Provider	Choose it when
   Latitude	You want open-source, self-hostable agent traces with token usage, cost, and built-in evaluations on top of OTLP.

Draft page content (ecosystem/tooling/latitude.md)

---
title: Latitude
description: Export Flue workflows, operations, model turns, tools, tasks, and compactions to Latitude as OpenTelemetry traces.
---

[Latitude](https://latitude.so) is an open-source observability and evaluation platform for LLM applications. It ingests OpenTelemetry traces, so Flue activity becomes spans you can inspect, search, and evaluate, with token usage, cost, and latency aggregated at every level of the trace.

Latitude builds on `@flue/opentelemetry`: the adapter converts Flue's live `observe(...)` event stream into OpenTelemetry spans, and an OTLP exporter delivers them to Latitude's ingestion endpoint. There is no separate Latitude package to install.

See [Observability](/docs/guide/observability/) for the observer model and a comparison of integrations.

## Quickstart

Install the Flue OpenTelemetry adapter alongside an OpenTelemetry SDK and OTLP exporter for your deployment target:

```sh
pnpm add @flue/opentelemetry @opentelemetry/api @opentelemetry/sdk-node @opentelemetry/exporter-trace-otlp-http
```

## Configure

Point the OTLP exporter at Latitude's ingestion endpoint and authenticate with a Latitude API key and project slug. Initialize the SDK before registering the observer, in your application entrypoint:

```ts title="src/app.ts (abridged)"
import { NodeSDK } from '@opentelemetry/sdk-node';
import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
import { createOpenTelemetryObserver } from '@flue/opentelemetry';
import { observe } from '@flue/runtime';

const sdk = new NodeSDK({
  traceExporter: new OTLPTraceExporter({
    url: 'https://ingest.latitude.so/v1/traces',
    headers: {
      Authorization: `Bearer ${process.env.LATITUDE_API_KEY}`,
      'X-Latitude-Project': process.env.LATITUDE_PROJECT ?? '',
    },
  }),
});

sdk.start();

observe(createOpenTelemetryObserver());
```

| Variable             | Purpose                                                                                  |
| -------------------- | ---------------------------------------------------------------------------------------- |
| `LATITUDE_API_KEY`   | Authenticates trace delivery. Create one in your Latitude project settings.              |
| `LATITUDE_PROJECT`   | The project slug that traces are written to. Must belong to the API key's organization.  |

Sign up for a Latitude account at [console.latitude.so](https://console.latitude.so/login), or self-host and point the exporter at your own ingestion host instead of `https://ingest.latitude.so`.

## What you get

Each Flue run shows up in Latitude as a trace with nested spans, following the `@flue/opentelemetry` span model:

| Flue activity          | Latitude span                                    |
| ---------------------- | ------------------------------------------------ |
| Workflow invocation    | `flue.workflow <name>` span                      |
| Finite agent operation | `flue.operation <kind>` span                     |
| Model turn             | `chat <model>` span with token usage and cost    |
| Tool call              | `flue.tool <name>` span                          |
| Delegated task         | `flue.task <agent>` span                         |
| Context compaction     | `flue.compaction` span                           |

Token usage, cost, and latency are aggregated at every level, and you can group multi-step runs into sessions and score outputs with Latitude's offline or live evaluations.

## Export content safely

By default `@flue/opentelemetry` exports metadata only: identifiers, durations, model and provider attributes, token and cost metadata, and generic failure messages. Workflow payloads, model input and output, tool values, and log content are omitted. Use the adapter's `exportContent(event)` hook to opt specific events into content export before sending them to Latitude. Review Latitude's retention and access controls before exporting model content.

## Verify

Run a workflow with a model turn and tool call, then open your project in the [Latitude dashboard](https://console.latitude.so/login) and confirm the span hierarchy, Flue correlation attributes, and token and cost metadata appear on the trace.

## Resources

- [Latitude documentation](https://docs.latitude.so)
- [Latitude OpenTelemetry tracing guide](https://docs.latitude.so/telemetry/start-tracing)
- [Latitude on GitHub](https://github.com/latitude-dev/latitude-llm)

I am a maintainer of Latitude and happy to keep this draft up to date, contribute an examples/latitude/ app, or adjust anything to fit how you prefer integrations to be shaped.