Use onRunCreate

langchain-core/src/tracers/tests/langchain_tracer.int.test.ts

@@ -2,7 +2,7 @@
 import * as uuid from "uuid";
 import { test } from "@jest/globals";
 
-import { LangChainTracer } from "../tracer_langchain.js";
+import { LangChainTracer, Run } from "../tracer_langchain.js";
 import { Serialized } from "../../load/serializable.js";
 import { HumanMessage } from "../../messages/index.js";
 
@@ -41,3 +41,37 @@ test("LangChain V2 tracer does not throw errors for its methods", async () => {
   await tracer.handleLLMStart(serialized, ["test"], llmRunId3);
   await tracer.handleLLMEnd({ generations: [[]] }, llmRunId3);
 });
+
+class FakeTracer extends LangChainTracer {
+  createOperations: { [id: string]: Run } = {};
+
+  updateOperations: { [id: string]: Run } = {};
+
+  async onRunCreate(run: Run): Promise<void> {
+    this.createOperations[run.id] = run;
+  }
+
+  async onRunUpdate(run: Run): Promise<void> {
+    this.updateOperations[run.id] = run;
+  }
+}
+
+test("LangChain V2 tracer creates and updates runs with trace_id and dotted_order", async () => {
+  const tracer = new FakeTracer({
+    projectName: `JS Int Test - ${uuid.v4()}`,
+  });
+  const chainRunId = uuid.v4();
+  const llmRunId = uuid.v4();
+  await tracer.handleChainStart(serialized, { foo: "bar" }, chainRunId);
+
+  await tracer.handleLLMStart(serialized, ["test"], llmRunId, chainRunId);
+  await tracer.handleLLMEnd({ generations: [[]] }, llmRunId);
+  await tracer.handleChainEnd({ foo: "bar" }, chainRunId);
+
+  expect(tracer.createOperations[chainRunId].trace_id).toBeDefined();
+  expect(tracer.createOperations[chainRunId].trace_id).toEqual(chainRunId);
+  expect(tracer.createOperations[chainRunId].dotted_order).toBeDefined();
+  expect(tracer.updateOperations[llmRunId].trace_id).toBeDefined();
+  expect(tracer.updateOperations[llmRunId].trace_id).toEqual(chainRunId);
+  expect(tracer.updateOperations[llmRunId].dotted_order).toBeDefined();
+});

langchain-core/src/tracers/tracer_langchain.ts

@@ -13,11 +13,20 @@ export interface Run extends BaseRun {
   id: string;
   child_runs: this[];
   child_execution_order: number;
+  dotted_order?: string;
+  trace_id?: string;
+}
+
+export interface RunCreate2 extends RunCreate {
+  trace_id?: string;
+  dotted_order?: string;
 }
 
 export interface RunUpdate extends BaseRunUpdate {
   events: BaseRun["events"];
   inputs: KVMap;
+  trace_id?: string;
+  dotted_order?: string;
 }
 
 export interface LangChainTracerFields extends BaseCallbackHandlerInput {
@@ -68,70 +77,25 @@ export class LangChainTracer
 
   protected async persistRun(_run: Run): Promise<void> {}
 
-  protected async _persistRunSingle(run: Run): Promise<void> {
-    const persistedRun: RunCreate = await this._convertToCreate(
+  async onRunCreate(run: Run): Promise<void> {
+    const persistedRun: RunCreate2 = await this._convertToCreate(
       run,
       this.exampleId
     );
     await this.client.createRun(persistedRun);
   }
 
-  protected async _updateRunSingle(run: Run): Promise<void> {
+  async onRunUpdate(run: Run): Promise<void> {
     const runUpdate: RunUpdate = {
       end_time: run.end_time,
       error: run.error,
       outputs: run.outputs,
       events: run.events,
       inputs: run.inputs,
+      trace_id: run.trace_id,
+      dotted_order: run.dotted_order,
+      parent_run_id: run.parent_run_id,
     };
     await this.client.updateRun(run.id, runUpdate);
   }
-
-  async onRetrieverStart(run: Run): Promise<void> {
-    await this._persistRunSingle(run);
-  }
-
-  async onRetrieverEnd(run: Run): Promise<void> {
-    await this._updateRunSingle(run);
-  }
-
-  async onRetrieverError(run: Run): Promise<void> {
-    await this._updateRunSingle(run);
-  }
-
-  async onLLMStart(run: Run): Promise<void> {
-    await this._persistRunSingle(run);
-  }
-
-  async onLLMEnd(run: Run): Promise<void> {
-    await this._updateRunSingle(run);
-  }
-
-  async onLLMError(run: Run): Promise<void> {
-    await this._updateRunSingle(run);
-  }
-
-  async onChainStart(run: Run): Promise<void> {
-    await this._persistRunSingle(run);
-  }
-
-  async onChainEnd(run: Run): Promise<void> {
-    await this._updateRunSingle(run);
-  }
-
-  async onChainError(run: Run): Promise<void> {
-    await this._updateRunSingle(run);
-  }
-
-  async onToolStart(run: Run): Promise<void> {
-    await this._persistRunSingle(run);
-  }
-
-  async onToolEnd(run: Run): Promise<void> {
-    await this._updateRunSingle(run);
-  }
-
-  async onToolError(run: Run): Promise<void> {
-    await this._updateRunSingle(run);
-  }
 }