01 — integrations

Twenty-four ways in, one way out

Every integration produces the same span model, so a trace that crosses four of them still reads as one timeline.

Showing all 24 integrations

AnthropicToken counts, cache hits and stop reasons captured per call.modelConnect
AWS BedrockCross-region inference profiles resolved to the model that actually ran.modelConnect
ClickHouseExport raw spans to your own cluster on a schedule you control.datastoreConnect
DagsterAsset materializations traced alongside the model calls inside them.pipelineConnect
GitHub ActionsRun evals on pull requests and fail the check when quality drops.pipelineConnect
Go SDKContext-propagating tracer with zero allocations on the hot path.sdkConnect
Google VertexGemini calls with safety-filter outcomes recorded as span events.modelConnect
LangGraphNode and edge boundaries become spans automatically, including retries.frameworkConnect
LlamaIndexRetrieval steps carry chunk counts and scores as span attributes.frameworkConnect
MastraWorkflow steps and agent hand-offs appear as a single nested trace.frameworkConnect
OpenAIChat, embeddings and batch endpoints, including tool-call arguments.modelConnect
OpenTelemetryPoint an OTLP exporter at Cinder. No vendor SDK required at all.sdkConnect
PagerDutyRoute eval regressions and latency breaches to the right rotation.alertingConnect
PineconeVector queries with top-k, filter and score distribution attached.datastoreConnect
PostgresQuery spans linked to the agent step that issued them.datastoreConnect
Pydantic AIValidation failures attach the offending payload to the span.frameworkConnect
Python SDKOne decorator per function, or auto-instrument the whole process at import time.sdkConnect
Rust SDKA tracing-subscriber layer, so existing spans flow through unchanged.sdkConnect
S3 / R2 exportHourly Parquet drops to your bucket. Your data leaves whenever you want.datastoreConnect
Self-hosted modelsvLLM, Ollama and TGI endpoints traced through the OpenAI-compatible shim.modelConnect
SlackThreaded alerts that link straight to the failing trace.alertingConnect
TypeScript SDKWorks in Node, Bun, Deno and edge runtimes. Ships its own types.sdkConnect
Vercel AI SDKStreaming responses traced token-by-token without buffering them.frameworkConnect
WebhooksSigned JSON payloads for anything we haven't built an integration for.alertingConnect

02 — otlp

Or use none of them

If your services already emit OpenTelemetry, there is nothing to install. Change two environment variables and your existing spans arrive as-is.

PythonTypeScriptGoOpenTelemetry

from cinder import trace, init

init(api_key=CINDER_API_KEY)

@trace
def review_contract(doc: str) -> Review:
    clauses = retrieve(doc)          # span: retrieve.clauses
    return compare(doc, clauses)     # span: agent.compare

import { init, trace } from '@cinder/sdk';

init({ apiKey: process.env.CINDER_API_KEY });

export const reviewContract = trace(
  'review_contract',
  async (doc: string) => {
    const clauses = await retrieve(doc);
    return compare(doc, clauses);
  },
);

import "github.com/cinder-dev/cinder-go"

func main() {
	cinder.Init(cinder.Config{APIKey: apiKey})
}

func ReviewContract(ctx context.Context, doc string) (*Review, error) {
	ctx, span := cinder.Start(ctx, "review_contract")
	defer span.End()

	clauses, err := Retrieve(ctx, doc)
	if err != nil {
		return nil, err
	}
	return Compare(ctx, doc, clauses)
}

# Already instrumented? Point your exporter at us
# and change nothing else.

export OTEL_EXPORTER_OTLP_ENDPOINT="https://in.cinder.dev"
export OTEL_EXPORTER_OTLP_HEADERS="x-cinder-key=${CINDER_API_KEY}"

Ask for the one you are missing.

Tell us what you are running. Integrations get built in the order customers ask for them.

$ npx @cinder/cli init

Request an integration

Or talk to an engineer — the same people who wrote the ingest path.