Skip to main content
skill CX Codex

doca-telemetry-exporter — Claude Code skill: what it does

Guides telemetry publishing, schema setup, and error debugging for applications linking the DOCA Telemetry Exporter library.

Apache-2.0 ★ 4,106 updated 2026-10-23

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add NVIDIA/skills --skill doca-telemetry-exporter -a claude-code
Open on GitHub

What doca-telemetry-exporter does

This skill guides developers through hands-on programming with the C library doca-telemetry-exporter. It enforces the schema-then-source lifecycle: initialize schema, register types, start schema, create source, start source, report data, and flush. The library does not follow DOCA Core context conventions, so calling doca_ctx_start() does not apply.

It assists in selecting the appropriate publish surface for downstream collectors. Supported surfaces include typed events, opaque events, metrics APIs (counters, gauges, histograms), OTLP logs, and NetFlow/IPFIX records. It also provides targeted debugging for exporter statuses such as DOCA_ERROR_BAD_STATE.

Running this requires an installed DOCA SDK at /opt/mellanox/doca on Linux (Ubuntu 22.04/24.04 or RHEL/SLES) alongside a BlueField DPU or ConnectX NIC. Validation checks inspect local files and invoke pkg-config doca-telemetry-exporter.

What it helps with

  • debug DOCA_ERROR_BAD_STATE failures during exporter reporting
  • choose between typed events, metrics APIs, OTLP logs, or NetFlow
  • implement the schema-then-source initialization lifecycle in C
  • inspect IPC connectivity between the exporter and downstream DTS

Example prompts for the agent

  • How do I emit my first structured event record from a DOCA Flow program?
  • Why does doca_telemetry_exporter_source_report return BAD_STATE on the first call?
  • Which publish surface should I link for per-interface packet counters and bandwidth gauges?

How to install doca-telemetry-exporter

1Skills CLI (Vercel)

npx skills add NVIDIA/skills --skill doca-telemetry-exporter -a claude-code

2Manually: put the files in place

~/.claude/skills/doca-telemetry-exporter/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/doca-telemetry-exporter/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about doca-telemetry-exporter

How to install doca-telemetry-exporter in Claude Code?

Run npx skills add NVIDIA/skills --skill doca-telemetry-exporter -a claude-code in your terminal. The skill file is placed in ~/.claude/skills/doca-telemetry-exporter/SKILL.md.

What does doca-telemetry-exporter do?

It assists developers writing C or C++ applications that publish telemetry metrics, events, and logs using the DOCA Telemetry Exporter library.

Does this skill cover DOCA Telemetry Service (DTS) configuration?

No, it focuses exclusively on the sending application side that links the exporter library. The receiving DOCA Telemetry Service daemon is handled separately.

Source text

SKILL.md · Apache-2.0
---
license: Apache-2.0
name: doca-telemetry-exporter
description: >
  Use this skill when the user is doing hands-on DOCA Telemetry Exporter
  programming on a host where DOCA is installed — defining a
  doca_telemetry_exporter_schema and event types, creating sources,
  picking a publish surface (typed events / opaque events / the metrics
  counter-gauge-histogram API / OTLP logs / NetFlow), walking the
  schema-then-source lifecycle, or debugging DOCA_ERROR_* failures from
  the exporter API. Trigger even when the user does not explicitly
  mention "DOCA Telemetry Exporter" or "doca_telemetry_exporter_*" —
  typical implicit phrasings include "publishing counters from my DOCA
  app", "BAD_STATE when I report an event", "consumer/DTS sees nothing
  but my report succeeded", "how do I export NetFlow/IPFIX records", or
  "should I link the exporter or the telemetry service". Refuse and
  route elsewhere for the receiving DOCA Telemetry Service (DTS), plain
  stdout logging via doca_log, or real-time event subscription back into
  the app via doca-comch — those belong to other skills.
metadata:
  author: NVIDIA <[email protected]>
  kind: library
  doca_version: "3.5"
  tags:
    - doca
    - telemetry
    - exporter
compatibility: >
  Requires DOCA SDK installed at /opt/mellanox/doca on Linux (Ubuntu
  22.04/24.04 or RHEL/SLES) with a BlueField DPU or ConnectX NIC
  attached. Reads the user's local install via `pkg-config
  doca-telemetry-exporter` and inspects
  /opt/mellanox/doca/{lib,include,samples,applications}. The validation
  steps require a live DOCA install.
---

# DOCA Telemetry Exporter

## Examples

- **"Publishing counters from my DOCA app."** — this is in
  scope. Walk schema-then-source; do not configure DTS here.
- **"BAD_STATE when I report an event."** — check the lifecycle
  order before changing the report call.

## Instructions

Follow Loading order below. Open the tasks companion for configure /
publish / debug. Open the capabilities companion for publish
surfaces. Do not open every companion file.

**Where to start:** This skill assumes DOCA is already installed and
the user is doing **hands-on telemetry-exporter work** — emitting
structured application telemetry (counters / events) from a
DOCA-using program to an external consumer. Open
the tasks companion if the user wants to *do* something (configure
/ build / modify + rebuild / run / test / debug); open
the capabilities companion when the question is *what can
the exporter express* on this install. If the user has not installed
DOCA yet, route to `doca-setup/SKILL.md` first.
If the user is confused about whether they want this library or the
DOCA Telemetry Service (the receiver) — read the
exporter-vs-service rule in
the capabilities companion
before configuring anything.

> **This library is NOT a DOCA Core context.** There is no
> `doca_ctx_start()` for the exporter and no per-`doca_devinfo`
> capability-query family (its `doca_caps` dump is a stub). The
> lifecycle is `schema_init` → configure exporters → register
> type(s) → `schema_start` → `source_create` → `source_start` →
> report → flush → destroy.

## Example questions this skill answers well

The CLASSES of telemetry-exporter questions this skill is built to
answer, each with one worked example. The agent should treat the
*class* as the load-bearing piece — the worked example is a single
instance.

- **"Which library do I want — the exporter or the telemetry
  service?"** — worked example: *"I want my DOCA Flow program to
  publish a per-second packets-processed counter to a downstream
  collector — which DOCA artifact do I link?"*. Answered by the
  exporter-vs-service rule in
  ## Capabilities and modes
  role-split table + the path-selection bullet, both of which name
  `doca-telemetry-exporter` as the publisher the application links
  and route the receiving / consuming side away from this skill.
- **"How do I emit my first structured event from a DOCA program?"** —
  worked example: *"emit a `packets_processed` event record from my
  DOCA Flow application"*. Answered by the schema → source
  lifecycle in
  ## Capabilities and modes
  object table + the workflow in
  ## configure +
  ## run step 3 (file-write smoke before
  bulk), starting from the `telemetry_export/` sample.
- **"Which publish surface do I want — typed events, metrics, OTLP
  logs, or NetFlow?"** — worked example: *"I want labeled
  per-interface packet counters and a bandwidth gauge"*. Answered
  by the publish-surface table in
  ## Capabilities and modes
  (that intent maps to the Metrics API — `_metrics_add_counter` /
  `_add_gauge` — and the `telemetry_export_metrics/` sample), plus
  the sample map in ## modify.
- **"My report call returns `DOCA_ERROR_BAD_STATE` — what did I
  get wrong?"** — worked example:
  *"`doca_telemetry_exporter_source_report` returns `BAD_STATE` on
  the first call"*. Answered by the `BAD_STATE` row in
  ## Error taxonomy
  (the source was never started, or an OTLP context is missing on
  write/flush) + the lifecycle order in
  ## configure. Note there is NO
  `DOCA_ERROR_AGAIN` and NO `DOCA_ERROR_NOT_FOUND` on this API.
- **"My program reports, but the DTS / collector sees nothing —
  where do I start?"** — worked example: *"my report returns
  success, but the DTS log is empty"*. Answered by the
  receiver-up-first staging in
  ## Safety policy
  + the file-write smoke and `check_ipc_status` steps in
  ## test (prove the publish half with
  file write, then confirm IPC is `CONNECTED` and the receiver
  is up).
- **"How do I confirm the exporter is installed and my transport
  is live?"** — worked example: *"is the exporter on my DOCA 3.x
  install, and is IPC to DTS actually connected?"*. Answered by
  the version-compatibility overlay in
  ## Version compatibility
  (cross-linking the detection chain in
  `doca-version/SKILL.md`) plus the honest
  introspection rule in
  ## Capabilities and modes
  (`doca_telemetry_exporter_check_ipc_status`, not a device
  cap-query).

## Audience

This skill serves **external developers building applications that
emit structured telemetry through DOCA Telemetry Exporter** — i.e.,
users whose application code calls `doca_telemetry_exporter_*`
(directly in C/C++, or through FFI/bindings from another language)
to publish counters, gauges, and events from their DOCA-using
program to an external telemetry consumer. It is *not* for NVIDIA
developers contributing to DOCA Telemetry Exporter itself, and it
is *not* for users building the receiving / aggregating telemetry
service (the DOCA Telemetry Service is a separate DOCA service with
its own public guide, reached via
`doca-public-knowledge-map/SKILL.md`).

**Language scope.** DOCA Telemetry Exporter ships as a C library
with `pkg-config` module name `doca-telemetry-exporter`. The
shipped samples are written in C. C and C++ consumers are the
canonical case; the worked examples in the tasks companion assume that path.
Other-language consumers (Rust, Go, Python, …) consume the same
`*.so` through FFI or language-specific bindings; the skill's
contribution in that case is to keep the exporter-vs-service
distinction, the schema → source lifecycle, the transport-not-caps
discovery rule, the same-user-as-the-app permission rule, the
buffered flush-based delivery model, and the error-taxonomy
guidance language-neutral, and to route the agent to the public C
ABI as the authoritative surface that any wrapper will eventually
call.

## When to load this skill

Load this skill when the user is doing hands-on DOCA Telemetry
Exporter work, in any language. Concretely:

- Defining a `doca_telemetry_exporter_schema` for the events the
  application will emit (field names + field types), and
  registering it with the exporter BEFORE any event is published.
- Creating one or more `doca_telemetry_exporter_source` instances
  to represent distinct logical sources of telemetry inside the
  application (e.g. one source per worker thread / per pipeline
  stage).
- Picking the right publish surface — typed structured events
  (`_source_report`), opaque events (`_source_opaque_report`), the
  Metrics API (counter / gauge / histogram), OTLP logs, or the
  NetFlow sibling API — for what the application reports.
- Confirming the exporter's install + transport reality (there is
  NO `doca_devinfo` cap-query family and NO `doca_caps` data for
  this library): `doca_telemetry_exporter_check_ipc_status` for
  IPC liveness, `_source_get_opaque_report_max_data_size` for the
  opaque payload bound, and the `_schema_get_*` config getters.
- Debugging a `DOCA_ERROR_*` returned from an exporter call
  (`BAD_STATE` lifecycle-order vs. `INVALID_VALUE` type/label
  mismatch vs. `NO_MEMORY` vs. `INITIALIZATION` vs. `UNKNOWN`
  backend) and the per-call status returned to the application.
- Choosing between Telemetry Exporter and an adjacent option
  (`doca_log` when stdout / structured-log shipping is enough; a
  Prometheus client library when the user needs a non-DOCA-aware
  sink; `doca-comch/SKILL.md` when the user
  needs a real-time event subscription back INTO the app — the
  exporter is publish-only / one-way).
- Designing or extending non-C bindings (Rust, Go, Python, …)
  that wrap the exporter C ABI — for the exporter-vs-service
  distinction, the schema → source lifecycle, the permission
  policy, the buffered flush-based delivery model, and the
  transport-introspection + error rules the wrapper must honor.

Do **not** load this skill for general DOCA orientation, install
of DOCA itself, the receiving telemetry service (the DOCA
Telemetry Service has its own public guide reachable through
`doca-public-knowledge-map/SKILL.md`),
or non-exporter library questions. For those, use
`doca-public-knowledge-map/SKILL.md`.

## What this skill provides

This is a **thin loader**. The body keeps only the orientation
needed to pick the right next file. The substantive
exporter-specific material lives in two companion files:

- the capabilities companion — what the exporter can express on this
  install: the exporter-vs-service role-split rule, the object
  family (`doca_telemetry_exporter_schema` → `_type`/`_field` →
  `_source` with the schema → source lifecycle), the four publish
  surfaces (typed events / opaque events / Metrics API / OTLP
  logs) plus the NetFlow sibling API, the transport-not-caps
  introspection rule (`check_ipc_status`,
  `_get_opaque_report_max_data_size`, `_schema_get_*` — NO
  `doca_caps` data, NO device cap-query), the exporter error
  taxonomy (mapped onto the cross-library `DOCA_ERROR_*` set, with
  the note that there is NO `AGAIN` and NO `NOT_FOUND` on this
  surface), the observability surface (per-call status + IPC
  status + file-write inspection + the receiver side as the
  end-to-end signal), the safety policy that gates the
  same-user-as-the-app permission and the receiver-up-first
  staging, and the path-selection rule against `doca_log` and
  `doca-comch`.
- the tasks companion — step-by-step workflows for the six in-scope
  exporter verbs: `configure`, `build`, `modify` (followed by a
  rebuild), `run`, `test`, `debug`. Plus a `Deferred task verbs` block that points
  out-of-scope questions at the right next skill.

The skill assumes a host where DOCA is already installed at the
standard location, the application runs as a user that can write
to the telemetry transport the exporter is configured for, and a
receiving telemetry consumer is reachable and started before the
exporter. It does not cover installing DOCA — that path goes
through `doca-setup/SKILL.md` — and it does
not cover configuring / operating the receiving telemetry service,
which is a separate DOCA service with its own public guide.

## What this skill deliberately does not ship

This skill is **agent guidance**, not a samples or templates
bundle. To keep the boundary clean, it deliberately does not
contain — and pull requests should not add:

- **Pre-written DOCA Telemetry Exporter application source code,
  in any language.** The verified exporter source code is the
  shipped C samples at
  `/opt/mellanox/doca/samples/doca_telemetry_exporter/`. The
  agent's job is to route the user to those files and prescribe a
  minimum-diff modification on them via the universal
  modify-a-sample workflow in
  `doca-programming-guide/SKILL.md`,
  layered with the exporter-specific overrides in
  ## modify.
- **A telemetry consumer / collector / receiving service.** The
  DOCA Telemetry Service is a separate DOCA service with its own
  public guide; routing to it goes through
  `doca-public-knowledge-map/SKILL.md`.
  This skill is about the publisher side only.
- **Standalone build manifests** (`meson.build`, `CMakeLists.txt`,
  `Cargo.toml`, …) parked inside the skill. The agent constructs
  the build manifest *in the user's project directory* against
  the user's installed DOCA, where `pkg-config --modversion
  doca-telemetry-exporter` is the source of truth.
- **A `samples/`, `bindings/`, or `reference/` subtree** of any
  kind. A mock or incomplete artifact in this skill's tree, even
  one labeled "reference", is misleading: users will read it as
  buildable.

## Loading order

1. Read this skill first to confirm the user's question is
   in scope.
2. **For the exporter-vs-service rule, the object family, the
   schema → source lifecycle, the four publish surfaces + NetFlow,
   the transport-not-caps introspection rule, the error taxonomy
   (note: no `AGAIN`, no `NOT_FOUND`), observability, the safety
   policy, and the path-selection rule against `doca_log` / comch,
   see the capabilities companion.**
3. **For step-by-step workflows — configure, build, modify,
   rebuild, run, test, debug — see the tasks companion.**

Both companion files cross-link to each other,
`doca-version/SKILL.md` for the canonical
version-handling rules, and
`doca-public-knowledge-map/SKILL.md`
whenever the right answer is "look it up in the public docs or
the installed package layout" rather than "exporter-specific
guidance".

## Related skills

- `doca-public-knowledge-map/SKILL.md` —
  the routing table for every public DOCA documentation source
  and the on-disk layout of an installed DOCA package. The
  exporter's public guide URL is
  `https://docs.nvidia.com/doca/sdk/DOCA-Telemetry-Exporter/index.html`;
  the on-disk samples live under
  `/opt/mellanox/doca/samples/doca_telemetry_exporter/`. The
  DOCA Telemetry Service (the *receiver*, out of scope here) is
  a separate guide reachable through that same routing table.
- `doca-setup/SKILL.md` — env preparation,
  install verification, transport-side reachability checks, and
  the *I have no install yet* path with the public NGC DOCA
  container. This skill assumes its preconditions are satisfied
  (in particular, the application user can write to the
  telemetry transport).
- `doca-version/SKILL.md` — canonical DOCA
  version-handling rules. This skill's `## Version compatibility`
  cross-links the four-way match rule + detection chain and adds
  the exporter-specific overlay rules.
- `doca-structured-tools-contract/SKILL.md` —
  the bundle's structured-tools precedence rule (detect / prefer
  / fall back / report). The Command appendix in
  the tasks companion honors this contract.
- `doca-programming-guide/SKILL.md` —
  general DOCA programming patterns shared by every library: the
  canonical `pkg-config` + meson build pattern, the universal
  modify-a-shipped-sample first-app workflow, the universal
  lifecycle, the cross-library `DOCA_ERROR_*` taxonomy, and the
  program-side debug order. This skill layers exporter specifics
  on top.
- `doca-comch/SKILL.md` — the right primitive
  when the user needs a real-time event subscription back INTO
  the application (host ↔ DPU control-plane messaging). The
  exporter is publish-only / one-way; this skill's
  path-selection rule routes there when subscription is the
  actual requirement.
- `doca-debug/SKILL.md` — the cross-cutting
  debug ladder (install / version / build / link / runtime /
  program / driver). Exporter-specific debug (receiver not up,
  lifecycle-order `BAD_STATE`, type/label `INVALID_VALUE`,
  opaque-path-not-enabled) overlays on top of that ladder.

© NVIDIA · Apache-2.0 · NVIDIA/skills

Similar skills

All skills for Backend and APIs →

From the same set312

The whole set →
doca-rdma doca-rdma — a skill for moving data over RDMA on NVIDIA BlueField or ConnectX NICs using RoCE and InfiniBand. CX Codex +1 ★ 4,106repo stars doca-flow-tune Assists in benchmarking and fine-tuning doca-flow pipelines on BlueField DPUs and ConnectX NICs using the doca_flow_tune utility. CX Codex +1 ★ 4,106repo stars doca-sta This skill guides DOCA STA NVMe-oF target work on BlueField, from checking device capabilities to sizing queues and diagnosing I/O errors. CX Codex +1 ★ 4,106repo stars doca-public-knowledge-map doca-public-knowledge-map is a Claude Code skill that locates official NVIDIA DOCA docs, libraries, samples, and paths. It activates when DOCA, BlueField, ConnectX, or /opt/mellanox is mentioned. CX Codex +1 ★ 4,106repo stars kermt-continue-pretrain The kermt-continue-pretrain skill continues KERMT pretraining on a custom SMILES dataset, preparing data, running training in a container, and saving outputs to a chosen directory. CX Codex +1 ★ 4,106repo stars kermt-finetune kermt-finetune — a skill to finetune a pretrained KERMT encoder on labeled CSV data. Validates checkpoint and data, prepares features, and runs training in a container. Requires Docker, nvidia-container-toolkit, and an NVIDIA GPU. CX Codex +1 ★ 4,106repo stars nvshmem-select-remote-transport nvshmem-select-remote-transport selects an NVSHMEM remote transport using static system facts and CUDA kernel inspection. Helps configure multi-node GPU communication without running benchmarks. CX Codex +1 ★ 4,106repo stars pva-doctor pva-doctor is a Claude Code skill that checks whether a host can handle requested NVIDIA PVA work. Run it before Spec, OpGen, Build-Test, or Debug. CX Codex +1 ★ 4,106repo stars

Project sponsors

Companies that keep this analytics open