Scalekit AgentKit Tracing

Scalekit AgentKit gives agents access to tools that act on a user’s connected accounts. Wrap each executeTool call with OpenInference’s traceTool helper to see the tool input, result, and status in Arize AX. If the call happens while an instrumented model span is active, the tool span is nested under that model span.

Prerequisites

A Node.js application using Scalekit AgentKit’s Node SDK
A Scalekit Development environment, connection, and active connected account
An Arize AX account with a Space ID and API key
An instrumented model client if you want tool calls nested under model spans

Install

Install OpenTelemetry and the Scalekit SDK:

npm install @scalekit-sdk/node \
  @opentelemetry/api \
  @opentelemetry/resources \
  @opentelemetry/sdk-trace-node \
  @opentelemetry/exporter-trace-otlp-proto \
  @opentelemetry/semantic-conventions \
  @arizeai/openinference-core \
  @arizeai/openinference-semantic-conventions

Configure credentials

Set the credentials in the environment where your Node application runs:

export ARIZE_SPACE_ID="<your-space-id>"
export ARIZE_API_KEY="<your-api-key>"
export ARIZE_PROJECT_NAME="scalekit-agentkit"
export SCALEKIT_ENVIRONMENT_URL="<your-development-environment-url>"
export SCALEKIT_CLIENT_ID="<your-client-id>"
export SCALEKIT_CLIENT_SECRET="<your-client-secret>"

Setup tracing

Register the tracer provider before constructing your model client or running your agent. This example uses the US AX endpoint; for an EU account, replace it with https://otlp.eu.arize.com/v1/traces.

import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-proto";
import { resourceFromAttributes } from "@opentelemetry/resources";
import { NodeTracerProvider, SimpleSpanProcessor } from "@opentelemetry/sdk-trace-node";
import { ATTR_SERVICE_NAME } from "@opentelemetry/semantic-conventions";
import { SEMRESATTRS_PROJECT_NAME } from "@arizeai/openinference-semantic-conventions";
import { ScalekitClient } from "@scalekit-sdk/node";

const projectName = process.env.ARIZE_PROJECT_NAME ?? "scalekit-agentkit";

export const provider = new NodeTracerProvider({
  resource: resourceFromAttributes({
    [ATTR_SERVICE_NAME]: projectName,
    [SEMRESATTRS_PROJECT_NAME]: projectName,
  }),
  spanProcessors: [
    new SimpleSpanProcessor(
      new OTLPTraceExporter({
        url: "https://otlp.arize.com/v1/traces",
        headers: {
          "arize-space-id": process.env.ARIZE_SPACE_ID ?? "",
          "arize-api-key": process.env.ARIZE_API_KEY ?? "",
        },
      }),
    ),
  ],
});

provider.register();

export const scalekit = new ScalekitClient(
  process.env.SCALEKIT_ENVIRONMENT_URL!,
  process.env.SCALEKIT_CLIENT_ID!,
  process.env.SCALEKIT_CLIENT_SECRET!,
);

Trace tool calls

Wrap Scalekit’s client.actions.executeTool with traceTool. It creates the TOOL span and records the call arguments and result by default. Set the span name from toolName; the input also includes the connector and identifier. Discover available tool names and schemas with Scalekit’s tool listing.

import { traceTool } from "@arizeai/openinference-core";
import type { ScalekitClient } from "@scalekit-sdk/node";

type ExecuteToolParams = Parameters<ScalekitClient["actions"]["executeTool"]>[0];

type ScalekitActions = Pick<ScalekitClient["actions"], "executeTool">;

export function createTracedToolExecutor(actions: ScalekitActions) {
  return (params: ExecuteToolParams) =>
    traceTool(
      (toolParams: ExecuteToolParams) => actions.executeTool(toolParams),
      { name: params.toolName },
    )(params);
}

Run

Call a read-only tool from your agent. Confirm the tool name and input schema in your Scalekit environment; the example below uses GitHub issue lookup.

import { scalekit } from "./instrumentation.js";
import { createTracedToolExecutor } from "./traced-tools.js";

const executeTool = createTracedToolExecutor(scalekit.actions);

const result = await executeTool({
  toolName: "github_issue_get",
  connector: "github-connect",
  identifier: "test-user",
  toolInput: { owner: "octocat", repo: "Hello-World", issue_number: 1 },
});
console.log(result.data);

Run the example with:

npx tsx example.ts

Open the project named by ARIZE_PROJECT_NAME in AX. The tool span should include the connector, tool name, input, and output. When model tracing is enabled, it should appear beneath the active model or agent span. Confirm spans are actually reaching your Arize AX project. Use whichever fits your workflow — the skill and CLI work for any framework; the SDK check is shown for each language.

Arize skill (agent)
AX CLI
SDK

Install the Arize Skills plugin and let your coding agent check for you:

npx skills add Arize-ai/arize-skills

Then prompt your agent:

Use the arize-trace skill to export and analyze recent traces from my project. Confirm spans are arriving, and summarize any errors or latency issues.

Export recent spans for your project — any rows mean traces are landing:

ax spans export "$ARIZE_PROJECT_NAME" --space "$ARIZE_SPACE_ID" \
  --limit 5 --stdout | jq 'length'

A non-zero count confirms spans reached Arize AX. Run ax auth login first if you have not authenticated. See the ax spans reference.

Query the project’s spans and check that at least one came back.

import os
from arize import ArizeClient

client = ArizeClient(api_key=os.environ["ARIZE_API_KEY"])
resp = client.spans.list(
    project=os.environ["ARIZE_PROJECT_NAME"],
    space=os.environ["ARIZE_SPACE_ID"],
    limit=5,
)
count = len(resp.spans)
print(
    f"{count} span(s) found" if count else "No spans yet — recheck setup"
)

// Reads ARIZE_API_KEY from the environment.
import { listSpans } from "@arizeai/ax-client";

const { data: spans } = await listSpans({
  project: process.env.ARIZE_PROJECT_NAME!,
  space: process.env.ARIZE_SPACE_ID!,
  limit: 5,
});
const count = spans.length;
console.log(
  count ? `${count} span(s) found` : "No spans yet — recheck setup",
);

client, err := arize.NewClient(
    arize.Config{APIKey: os.Getenv("ARIZE_API_KEY")},
)
if err != nil {
    log.Fatal(err)
}
resp, err := client.Spans.List(ctx, spans.ListRequest{
    Project: os.Getenv("ARIZE_PROJECT_NAME"),
    Space:   os.Getenv("ARIZE_SPACE_ID"),
    Limit:   5,
})
if err != nil {
    log.Fatal(err)
}
fmt.Printf("%d span(s) found\n", len(resp.Spans))

OpenTelemetry

LLM Providers

Agent Frameworks

Coding Agents

Platforms

Orchestration

Evaluation

Scalekit AgentKit Tracing

Prerequisites

Install

Configure credentials

Setup tracing

Trace tool calls

Run

Resources

Scalekit execute a tool

Scalekit connectors

Scalekit tracing demo

​Prerequisites

​Install

​Configure credentials

​Setup tracing

​Trace tool calls

​Run

​Resources

Scalekit execute a tool

Scalekit connectors

Scalekit tracing demo

Prerequisites

Install

Configure credentials

Setup tracing

Trace tool calls

Run

Resources