@arizeai/openinference-instrumentation-beeai 1.0.0

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@arizeai/openinference-instrumentation-beeai",
+  "version": "1.0.0",
+  "license": "Apache-2.0",
+  "author": "gallas.milan@gmail.com",
+  "description": "OpenInference Instrumentation for BeeAI framework",
+  "private": false,
+  "main": "dist/src/index.js",
+  "module": "dist/esm/index.js",
+  "esnext": "dist/esnext/index.js",
+  "types": "dist/src/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Arize-ai/openinference.git"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/esm/index.js",
+      "require": "./dist/src/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "keywords": [
+    "beeai",
+    "opentelemetry",
+    "tracing"
+  ],
+  "dependencies": {
+    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/instrumentation": "^0.57.1",
+    "remeda": "^2.20.2",
+    "@arizeai/openinference-core": "1.0.0",
+    "@arizeai/openinference-semantic-conventions": "1.0.0"
+  },
+  "peerDependencies": {
+    "beeai-framework": "^0.1.5"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.12",
+    "@types/node": "^20.14.11",
+    "beeai-framework": "^0.1.5",
+    "import-in-the-middle": "^1.13.0",
+    "@opentelemetry/exporter-trace-otlp-proto": "^0.50.0",
+    "@opentelemetry/resources": "^1.30.1",
+    "@opentelemetry/sdk-node": "^0.57.1",
+    "@opentelemetry/sdk-trace-node": "^1.30.1",
+    "@opentelemetry/semantic-conventions": "^1.28.0",
+    "jest": "^29.7.0",
+    "ts-node": "^10.9.2"
+  },
+  "optionalDependencies": {
+    "ollama": "^0.5.12"
+  },
+  "scripts": {
+    "prebuild": "rimraf dist",
+    "build": "tsc --build tsconfig.json tsconfig.esm.json tsconfig.esnext.json && tsc-alias -p tsconfig.esm.json",
+    "postbuild": "echo '{\"type\": \"module\"}' > ./dist/esm/package.json && rimraf dist/test",
+    "type:check": "tsc --noEmit",
+    "test": "jest"
+  }
+}

package/src/config.ts

@@ -0,0 +1,48 @@
+/**
+ * Copyright 2025 IBM Corp.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { BeeCallbacks } from "beeai-framework/agents/bee/types";
+import { ChatModelEvents } from "beeai-framework/backend/chat";
+import { ToolEvents } from "beeai-framework/tools/base";
+
+export const INSTRUMENTATION_IGNORED_KEYS = process.env
+  .BEE_FRAMEWORK_INSTRUMENTATION_IGNORED_KEYS
+  ? process.env.BEE_FRAMEWORK_INSTRUMENTATION_IGNORED_KEYS.split(",").filter(
+      Boolean,
+    )
+  : [];
+
+export const partialUpdateEventName: keyof BeeCallbacks = "partialUpdate";
+export const updateEventName: keyof BeeCallbacks = "update";
+export const toolErrorEventName: keyof BeeCallbacks = "toolError";
+export const toolStartEventName: keyof BeeCallbacks = "toolStart";
+export const toolSuccessEventName: keyof BeeCallbacks = "toolSuccess";
+export const startEventName: keyof BeeCallbacks = "start";
+export const successEventName: keyof BeeCallbacks = "success";
+export const errorEventName: keyof BeeCallbacks = "error";
+export const retryEventName: keyof BeeCallbacks = "retry";
+
+export const newTokenLLMEventName: keyof ChatModelEvents = `newToken`;
+export const successLLMEventName: keyof ChatModelEvents = `success`;
+export const startLLMEventName: keyof ChatModelEvents = `start`;
+export const errorLLMEventName: keyof ChatModelEvents = `error`;
+export const finishLLMEventName: keyof ChatModelEvents = `finish`;
+
+export const startToolEventName: keyof ToolEvents = "start";
+export const successToolEventName: keyof ToolEvents = "success";
+export const finishToolEventName: keyof ToolEvents = "finish";
+export const retryToolEventName: keyof ToolEvents = "retry";
+export const errorToolEventName: keyof ToolEvents = "error";

package/src/helpers/buildTraceTree.ts

@@ -0,0 +1,118 @@
+import { OITracer } from "@arizeai/openinference-core";
+import { FrameworkSpan, GeneratedResponse } from "../types";
+import { SpanStatusCode, TimeInput } from "@opentelemetry/api";
+import {
+  OpenInferenceSpanKind,
+  SemanticConventions,
+} from "@arizeai/openinference-semantic-conventions";
+
+interface BuiltTraceTreeProps {
+  tracer: OITracer;
+  data: {
+    prompt?: string | null;
+    history: GeneratedResponse[] | undefined;
+    generatedMessage: GeneratedResponse | undefined;
+    spans: FrameworkSpan[];
+    traceId: string;
+    version: string;
+    runErrorSpanKey: string;
+    startTime: TimeInput;
+    endTime: TimeInput;
+    source: string;
+  };
+}
+
+interface BuildSpansForParentProps {
+  tracer: OITracer;
+  data: {
+    spans: FrameworkSpan[];
+    traceId: string;
+    parentId: string | undefined;
+  };
+}
+
+function buildSpansForParent({ tracer, data }: BuildSpansForParentProps) {
+  data.spans
+    .filter((beeaiSpan) => beeaiSpan.parent_id === data.parentId)
+    .forEach((beeaiSpan) => {
+      tracer.startActiveSpan(
+        beeaiSpan.context.span_id,
+        {
+          // custom start time
+          startTime: beeaiSpan.start_time,
+          // set span important attributes
+          attributes: {
+            target: beeaiSpan.attributes.target,
+            name: beeaiSpan.name,
+            traceId: data.traceId,
+            ...(beeaiSpan.attributes.metadata && {
+              metadata: JSON.stringify(beeaiSpan.attributes.metadata),
+            }),
+            ...(beeaiSpan.attributes.data && { ...beeaiSpan.attributes.data }),
+          },
+        },
+        (activeSpan) => {
+          // set status
+          activeSpan.setStatus(beeaiSpan.status);
+
+          // set nested spans
+          buildSpansForParent({
+            tracer,
+            data: {
+              spans: data.spans,
+              traceId: data.traceId,
+              parentId: beeaiSpan.context.span_id,
+            },
+          });
+
+          // finish the span
+          activeSpan.end(beeaiSpan.end_time);
+        },
+      );
+    });
+}
+
+export function buildTraceTree({ tracer, data }: BuiltTraceTreeProps) {
+  tracer.startActiveSpan(
+    `beeai-framework-main`,
+    {
+      // custom start time
+      startTime: data.startTime,
+      // set main span important attributes
+      attributes: {
+        source: data.source,
+        traceId: data.traceId,
+        [SemanticConventions.OPENINFERENCE_SPAN_KIND]:
+          OpenInferenceSpanKind.AGENT,
+        ["beeai.version"]: data.version,
+        ...(data.prompt && { [SemanticConventions.INPUT_VALUE]: data.prompt }),
+        ...(data.generatedMessage !== undefined && {
+          [SemanticConventions.OUTPUT_VALUE]: JSON.stringify(
+            data.generatedMessage,
+          ),
+        }),
+        ...(data.history && { history: JSON.stringify(data.history) }),
+      },
+    },
+    (activeSpan) => {
+      // set status
+      const runErrorSpan = data.spans.find(
+        (span) => span.attributes.target === data.runErrorSpanKey,
+      );
+      if (runErrorSpan) {
+        activeSpan.setStatus(runErrorSpan.status);
+      } else {
+        activeSpan.setStatus({ code: SpanStatusCode.OK });
+      }
+
+      // set nested spans
+      buildSpansForParent({
+        tracer,
+        data: { spans: data.spans, traceId: data.traceId, parentId: undefined },
+      });
+
+      // finish the main span with custom end time
+      activeSpan.end(data.endTime);
+    },
+  );
+}

package/src/helpers/create-span.ts

@@ -0,0 +1,66 @@
+/**
+ * Copyright 2025 IBM Corp.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { SpanStatusCode, TimeInput } from "@opentelemetry/api";
+import { FrameworkSpan } from "../types";
+import { isEmpty } from "remeda";
+
+interface CreateSpanProps {
+  id: string;
+  name: string;
+  target: string;
+  startedAt: TimeInput;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  ctx?: any;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  data?: any;
+  error?: string;
+  parent?: { id: string };
+}
+
+export function createSpan({
+  target,
+  name,
+  data,
+  error,
+  ctx,
+  parent,
+  id,
+  startedAt,
+}: CreateSpanProps): FrameworkSpan {
+  return {
+    name: name,
+    attributes: {
+      target,
+      metadata: ctx && !isEmpty(ctx) ? { ...ctx } : undefined,
+      ...(error && {
+        "exception.message": error,
+        "exception.type": "FrameworkError",
+      }),
+      data: data && !isEmpty(data) ? { ...data } : null,
+    },
+    context: {
+      span_id: id,
+    },
+    parent_id: parent?.id,
+    status: {
+      code: error ? SpanStatusCode.ERROR : SpanStatusCode.OK,
+      message: error ? error : "",
+    },
+    start_time: startedAt,
+    end_time: performance.now(),
+  };
+}

package/src/helpers/getErrorSafe.ts

@@ -0,0 +1,26 @@
+/**
+ * Copyright 2025 IBM Corp.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { FrameworkError } from "beeai-framework/errors";
+import { getProp } from "beeai-framework/internals/helpers/object";
+
+export function getErrorSafe(data: unknown): string | undefined {
+  const error = getProp(data, ["error"], data);
+
+  if (error instanceof FrameworkError) {
+    return FrameworkError.ensure(error).explain();
+  }
+}

package/src/helpers/getSerializedObjectSafe.ts

@@ -0,0 +1,325 @@
+/**
+ * Copyright 2025 IBM Corp.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { Serializable } from "beeai-framework/internals/serializable";
+import { instrumentationLogger } from "beeai-framework/instrumentation/logger";
+import { getProp } from "beeai-framework/internals/helpers/object";
+import { EventMeta, InferCallbackValue } from "beeai-framework/emitter/types";
+import { BeeCallbacks } from "beeai-framework/agents/bee/types";
+import { ChatModel, ChatModelEvents } from "beeai-framework/backend/chat";
+import { BaseAgent } from "beeai-framework/agents/base";
+import { Message, MessageContentPart } from "beeai-framework/backend/message";
+import {
+  errorEventName,
+  errorLLMEventName,
+  errorToolEventName,
+  finishLLMEventName,
+  finishToolEventName,
+  newTokenLLMEventName,
+  partialUpdateEventName,
+  retryEventName,
+  retryToolEventName,
+  startEventName,
+  startLLMEventName,
+  startToolEventName,
+  successEventName,
+  successLLMEventName,
+  successToolEventName,
+  toolErrorEventName,
+  toolStartEventName,
+  toolSuccessEventName,
+  updateEventName,
+} from "../config";
+import {
+  LLMAttributePostfixes,
+  MessageAttributePostfixes,
+  MimeType,
+  OpenInferenceSpanKind,
+  SemanticAttributePrefixes,
+  SemanticConventions,
+} from "@arizeai/openinference-semantic-conventions";
+import { Tool, ToolEvents } from "beeai-framework/tools/base";
+
+function parserLLMInputMessages(
+  messages: readonly Message<MessageContentPart, string>[],
+) {
+  return messages.reduce(
+    (acc, item, key) => ({
+      ...acc,
+      [`${SemanticAttributePrefixes.llm}.${LLMAttributePostfixes.input_messages}.${key}.${SemanticAttributePrefixes.message}.${MessageAttributePostfixes.role}`]:
+        item.role,
+      [`${SemanticAttributePrefixes.llm}.${LLMAttributePostfixes.input_messages}.${key}.${SemanticAttributePrefixes.message}.${MessageAttributePostfixes.content}`]:
+        item.content
+          .filter((c) => c.type === "text")
+          .map((c) => c.text)
+          .join(""),
+    }),
+    {},
+  );
+}
+
+function parseLLMOutputMessages(
+  messages: readonly Message<MessageContentPart, string>[],
+) {
+  return messages.reduce(
+    (acc, item, key) => ({
+      ...acc,
+      [`${SemanticAttributePrefixes.llm}.${LLMAttributePostfixes.output_messages}.${key}.${SemanticAttributePrefixes.message}.${MessageAttributePostfixes.role}`]:
+        item.role,
+      [`${SemanticAttributePrefixes.llm}.${LLMAttributePostfixes.output_messages}.${key}.${SemanticAttributePrefixes.message}.${MessageAttributePostfixes.content}`]:
+        item.content
+          .filter((c) => c.type === "text")
+          .map((c) => c.text)
+          .join(""),
+    }),
+    {},
+  );
+}
+
+export function getSerializedObjectSafe(
+  dataObject: unknown,
+  meta: EventMeta<unknown>,
+) {
+  // agent events
+  if (
+    [startEventName, successEventName, errorEventName, retryEventName].includes(
+      meta.name as keyof BeeCallbacks,
+    ) &&
+    meta.creator instanceof BaseAgent
+  ) {
+    const { meta, tools, memory, error, data } =
+      dataObject as InferCallbackValue<
+        | BeeCallbacks["start"]
+        | BeeCallbacks["error"]
+        | BeeCallbacks["success"]
+        | BeeCallbacks["retry"]
+      >;
+    return {
+      [SemanticConventions.OPENINFERENCE_SPAN_KIND]:
+        OpenInferenceSpanKind.AGENT,
+      iteration: meta.iteration,
+      ...(tools?.length > 0 && {
+        [SemanticConventions.LLM_TOOLS]: tools.map((tool) => ({
+          [SemanticConventions.TOOL_NAME]: tool.name,
+          [SemanticConventions.TOOL_DESCRIPTION]: tool.description,
+          "tool.options": tool.options,
+        })),
+      }),
+      ...(memory.messages.length > 0 && {
+        [SemanticConventions.INPUT_MIME_TYPE]: MimeType.JSON,
+        [SemanticConventions.INPUT_VALUE]: JSON.stringify(memory.messages),
+      }),
+      ...(error && {
+        "exception.message": error.message,
+        "exception.stacktrace": error.stack,
+        "exception.type": error.name,
+      }),
+      ...(data && {
+        [SemanticConventions.OUTPUT_MIME_TYPE]: MimeType.JSON,
+        [SemanticConventions.OUTPUT_VALUE]: JSON.stringify(data),
+      }),
+    };
+  }
+
+  // update events
+  if (
+    [updateEventName, partialUpdateEventName].includes(
+      meta.name as keyof BeeCallbacks,
+    )
+  ) {
+    const { data } = dataObject as InferCallbackValue<
+      BeeCallbacks["partialUpdate"] | BeeCallbacks["update"]
+    >;
+
+    const output = data.final_answer || data.tool_output;
+    return {
+      [SemanticConventions.OPENINFERENCE_SPAN_KIND]:
+        OpenInferenceSpanKind.AGENT,
+      thought: data.thought,
+      ...(data.tool_name && {
+        [SemanticConventions.TOOL_NAME]: data.tool_name,
+      }),
+      ...(data.tool_input && {
+        [SemanticConventions.TOOL_PARAMETERS]: JSON.stringify(data.tool_input),
+      }),
+      ...(output && {
+        [SemanticConventions.OUTPUT_MIME_TYPE]: MimeType.JSON,
+        [SemanticConventions.OUTPUT_VALUE]: output,
+      }),
+    };
+  }
+
+  // tool events (from agent)
+  if (
+    [toolErrorEventName, toolStartEventName, toolSuccessEventName].includes(
+      meta.name as keyof BeeCallbacks,
+    )
+  ) {
+    const { data } = dataObject as InferCallbackValue<
+      | BeeCallbacks["toolError"]
+      | BeeCallbacks["toolStart"]
+      | BeeCallbacks["toolSuccess"]
+    >;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const output: any = data.result && data.result.createSnapshot();
+
+    return {
+      [SemanticConventions.OPENINFERENCE_SPAN_KIND]: OpenInferenceSpanKind.TOOL,
+      thought: data.iteration.thought,
+      ...(data.input
+        ? { [SemanticConventions.TOOL_PARAMETERS]: JSON.stringify(data.input) }
+        : {}),
+      ...(data.tool.description && {
+        [SemanticConventions.TOOL_DESCRIPTION]: data.tool.description,
+      }),
+      ...(data.tool.name && {
+        [SemanticConventions.TOOL_NAME]: data.tool.name,
+      }),
+      ...(data.error && {
+        "exception.message": data.error.message,
+        "exception.stacktrace": data.error.stack,
+        "exception.type": data.error.name,
+      }),
+      ...(output && {
+        [SemanticConventions.OUTPUT_VALUE]: JSON.stringify(output),
+      }),
+    };
+  }
+  // tool events native
+  if (
+    [
+      startToolEventName,
+      successToolEventName,
+      finishToolEventName,
+      errorToolEventName,
+      retryToolEventName,
+    ].includes(meta.name as keyof ToolEvents) &&
+    meta.creator instanceof Tool
+  ) {
+    if (!dataObject) {
+      return {
+        [SemanticConventions.OPENINFERENCE_SPAN_KIND]:
+          OpenInferenceSpanKind.TOOL,
+      };
+    }
+    const { input, output, error } = dataObject as InferCallbackValue<
+      | ToolEvents["start"]
+      | ToolEvents["success"]
+      | ToolEvents["retry"]
+      | ToolEvents["error"]
+    >;
+
+    return {
+      [SemanticConventions.OPENINFERENCE_SPAN_KIND]: OpenInferenceSpanKind.TOOL,
+      ...(input
+        ? { [SemanticConventions.TOOL_PARAMETERS]: JSON.stringify(input) }
+        : {}),
+      ...(output && {
+        [SemanticConventions.OUTPUT_VALUE]: JSON.stringify(output),
+      }),
+      ...(error && {
+        "exception.message": error.message,
+        "exception.stacktrace": error.stack,
+        "exception.type": error.name,
+      }),
+    };
+  }
+
+  // llm events
+  if (
+    [
+      successLLMEventName,
+      startLLMEventName,
+      errorLLMEventName,
+      newTokenLLMEventName,
+    ].includes(meta.name as keyof ChatModelEvents) &&
+    meta.creator instanceof ChatModel
+  ) {
+    const { value, input, error } = dataObject as InferCallbackValue<
+      | ChatModelEvents["success"]
+      | ChatModelEvents["start"]
+      | ChatModelEvents["error"]
+      | ChatModelEvents["newToken"]
+    >;
+
+    const creator = meta.creator.createSnapshot();
+    return {
+      [SemanticConventions.OPENINFERENCE_SPAN_KIND]: OpenInferenceSpanKind.LLM,
+      ...(value?.usage?.completionTokens && {
+        [SemanticConventions.LLM_TOKEN_COUNT_COMPLETION]:
+          value?.usage?.completionTokens,
+      }),
+      ...(value?.usage?.promptTokens && {
+        [SemanticConventions.LLM_TOKEN_COUNT_PROMPT]:
+          value?.usage?.promptTokens,
+      }),
+      ...(value?.usage?.totalTokens && {
+        [SemanticConventions.LLM_TOKEN_COUNT_TOTAL]: value?.usage?.totalTokens,
+      }),
+      ...(input?.messages.length > 0 && {
+        [SemanticConventions.INPUT_MIME_TYPE]: MimeType.JSON,
+        [SemanticConventions.INPUT_VALUE]: JSON.stringify(input.messages),
+        ...parserLLMInputMessages(input.messages),
+      }),
+      ...(value?.messages.length > 0 && {
+        [SemanticConventions.OUTPUT_MIME_TYPE]: MimeType.JSON,
+        [SemanticConventions.OUTPUT_VALUE]: JSON.stringify(value.messages),
+        ...parseLLMOutputMessages(value.messages),
+      }),
+      ...(error && {
+        "exception.message": error.message,
+        "exception.stacktrace": error.stack,
+        "exception.type": error.name,
+      }),
+      ...("providerId" in creator && {
+        [SemanticConventions.LLM_PROVIDER]: creator.providerId,
+        [`${SemanticAttributePrefixes.metadata}.${LLMAttributePostfixes.provider}`]:
+          creator.providerId,
+      }),
+      ...("modelId" in creator && {
+        [SemanticConventions.LLM_MODEL_NAME]: creator.modelId,
+        [`${SemanticAttributePrefixes.metadata}.${LLMAttributePostfixes.model_name}`]:
+          creator.modelId,
+      }),
+      ...(creator.parameters && {
+        [SemanticConventions.LLM_INVOCATION_PARAMETERS]: JSON.stringify(
+          creator.parameters,
+        ),
+      }),
+    };
+  }
+  if (meta.name === finishLLMEventName && meta.creator instanceof ChatModel) {
+    return {
+      [SemanticConventions.OPENINFERENCE_SPAN_KIND]: OpenInferenceSpanKind.LLM,
+    };
+  }
+
+  // other events
+  const data = getProp(dataObject, ["data"], dataObject);
+  if (data instanceof Serializable) {
+    try {
+      return { data: JSON.stringify(data.createSnapshot()), test: "hallo" };
+    } catch (e) {
+      instrumentationLogger.warn(
+        e,
+        "Invalid createSnapshot method in the Serializable class",
+      );
+      return null;
+    }
+  }
+
+  return { data: JSON.stringify(data) };
+}

package/src/helpers/idNameManager.ts

@@ -0,0 +1,53 @@
+/**
+ * Copyright 2025 IBM Corp.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+interface GetIdsProps {
+  path: string;
+  id: string;
+  runId: string;
+  parentRunId?: string;
+  groupId?: string;
+}
+
+export class IdNameManager {
+  /** Current index for each event */
+  #idNamesCounter = new Map<string, number>();
+  /** The new span id names and the original framework emitter event ids dictionary */
+  #idNameMap = new Map<string, string>();
+  /** We need to map the run tree structure with duplicities to the event tree structure */
+  #runIdMap = new Map<string, string>();
+
+  #spanIdGenerator(name: string) {
+    const count = this.#idNamesCounter.get(name) || 0;
+    this.#idNamesCounter.set(name, count + 1);
+    return `${name}-${this.#idNamesCounter.get(name)}`;
+  }
+
+  getIds({ path, id, runId, parentRunId, groupId }: GetIdsProps) {
+    this.#runIdMap.set(runId, id);
+    const spanId = this.#spanIdGenerator(path);
+
+    this.#idNameMap.set(id, spanId);
+    const parentSpanId = parentRunId
+      ? this.#idNameMap.get(this.#runIdMap.get(parentRunId) || "")
+      : groupId;
+
+    return {
+      spanId,
+      parentSpanId,
+    };
+  }
+}