Privacy controls

The SDK sends span payloads — prompts, completions, tool arguments — to Agent Registry by default. Three controls change that, and all of them fail closed: when a control breaks, data is withheld rather than leaked.

Suppress content entirely

trace_content: false stops input, output, metadata, and tool payloads from being recorded, while keeping the structural telemetry: span names, observation types, model, provider, usage, cost, and scores.

client = atlan_ai.init(service_name="support-rover", trace_content=False)

const client = atlan.init({ serviceName: "support-rover", traceContent: false });

ATLAN_TRACE_CONTENT=false does the same without a code change. This also stamps atlan.consent.store_content=false on the resource, so the Gateway’s consent gate enforces the same decision server-side. The suppression does not depend on the client alone. Use this when you need cost, latency, and quality metrics but the payloads themselves must not leave your environment.

Mask specific values

When you need most content but must redact parts of it, use a mask hook instead of suppressing everything.

Data-level masking

mask runs when your own spans’ input, output, and metadata are recorded. It receives the value and returns the redacted replacement.

def mask(*, data, **_):
    return redact_pii(data)


client = atlan_ai.init(service_name="support-rover", mask=mask)

const client = atlan.init({
  serviceName: "support-rover",
  mask: ({ data }) => redactPii(data),
});

Accept extra keyword arguments in Python (**_) so the hook keeps working if the SDK passes additional context in a later version. If your mask raises, the value is replaced with [atlan: value withheld - mask hook failed] rather than sent unmasked.

Export-stage masking

mask only sees spans the SDK created. Spans from third-party instrumentation — OpenLLMetry, OpenInference, a framework’s native OTel — bypass it. To reach those, use mask_otel_spans / maskOtelSpans, which runs over the whole export batch and returns a patch per span.

def mask_otel_spans(params):
    return {
        ident: atlan_ai.OtelSpanPatch(delete_attributes=["gen_ai.input.messages"])
        for ident, span in params.items()
        if "gen_ai.input.messages" in span.attributes
    }


client = atlan_ai.init(service_name="support-rover", mask_otel_spans=mask_otel_spans)

const client = atlan.init({
  serviceName: "support-rover",
  maskOtelSpans: (spans) => {
    const patches = new Map();
    for (const [key, span] of spans) {
      if ("gen_ai.input.messages" in span.attributes) {
        patches.set(key, { deleteAttributes: ["gen_ai.input.messages"] });
      }
    }
    return patches;
  },
});

A patch can delete attributes or set replacement values. Return no patch for a span to leave it unchanged. Failure handling is deliberately blunt here, because a partial result cannot be trusted:

What went wrong	What happens
the hook raises	the whole batch is dropped
the hook returns an invalid shape	the whole batch is dropped
one patch is invalid	that single span is dropped

Dropping a batch means losing those traces. Test a masking hook against representative spans before enabling it in production, and watch for dropping batch warnings after you deploy it.

Control volume

Two independent controls reduce how much is exported. The export allowlist decides which spans are eligible at all. By default the SDK exports its own spans plus spans from recognized GenAI instrumentors, and drops unrelated application spans. Replace the decision entirely with should_export_span / shouldExportSpan if you need different rules. Sampling drops a fraction of traces. Set sample_rate between 0.0 and 1.0, or ATLAN_SAMPLE_RATE. A value outside that range is ignored with a warning and treated as 1.0.

Sampling applies only when the SDK creates the TracerProvider. If your application owns the provider, the standard OTEL_TRACES_SAMPLER and OTEL_TRACES_SAMPLER_ARG variables govern sampling and the SDK does not override them.

Running alongside another tracing vendor

If you already export to Langfuse, Braintrust, or another OTel backend, isolated: true (TypeScript) keeps the SDK off the global TracerProvider and runs a private pipeline, so neither vendor receives the other’s spans.

const client = atlan.init({ serviceName: "support-rover", isolated: true });

If your application owns the provider and you want Atlan spans in it, pass client.spanProcessor into your provider’s constructor instead of letting the SDK register globally.

Overview

CLI

SDK

Cookbooks

Operate safely

API reference

Suppress content entirely

Mask specific values

Data-level masking

Export-stage masking

Control volume

Running alongside another tracing vendor

Next steps

Configuration

Serverless

​Suppress content entirely

​Mask specific values

​Data-level masking

​Export-stage masking

​Control volume

​Running alongside another tracing vendor

​Next steps

Configuration

Serverless

Suppress content entirely

Mask specific values

Data-level masking

Export-stage masking

Control volume

Running alongside another tracing vendor

Next steps