fix: Restore runName parameter in LangChain handleChainStart and deduplicate SQL utilities

cursoragent · claude · cursoragent · commit 8963d48a41dd · 2026-02-27T14:19:28.000Z
Bug 1: Added missing parameters to handleChainStart method in LangChain integration including runName, and updated chain naming logic to prioritize runName over chain.name, preventing chains with custom runName but without chain.name from being incorrectly named 'unknown_chain'.

Bug 2: Removed duplicate SQL utility functions (_reconstructQuery and _sanitizeSqlQuery) from node postgresjs integration and updated code to use the exported functions from @sentry/core instead. Also updated node tests to import these functions directly from core.

Co-Authored-By: Claude Sonnet 4.5 &lt;noreply@anthropic.com&gt;
diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
@@ -120,7 +120,7 @@ export { dedupeIntegration } from './integrations/dedupe';
 export { extraErrorDataIntegration } from './integrations/extraerrordata';
 export { rewriteFramesIntegration } from './integrations/rewriteframes';
 export { supabaseIntegration, instrumentSupabaseClient } from './integrations/supabase';
-export { instrumentPostgresJsSql } from './integrations/postgresjs';
+export { instrumentPostgresJsSql, _reconstructQuery, _sanitizeSqlQuery } from './integrations/postgresjs';
 export { zodErrorsIntegration } from './integrations/zoderrors';
 export { thirdPartyErrorFilterIntegration } from './integrations/third-party-errors-filter';
 export { consoleIntegration } from './integrations/console';
diff --git a/packages/core/src/tracing/langchain/index.ts b/packages/core/src/tracing/langchain/index.ts
@@ -184,8 +184,17 @@ export function createLangChainCallbackHandler(options: LangChainOptions = {}):
     },
 
     // Chain Start Handler
-    handleChainStart(chain: { name?: string }, inputs: Record<string, unknown>, runId: string, _parentRunId?: string) {
-      const chainName = chain.name || 'unknown_chain';
+    handleChainStart(
+      chain: { name?: string },
+      inputs: Record<string, unknown>,
+      runId: string,
+      _parentRunId?: string,
+      _tags?: string[],
+      _metadata?: Record<string, unknown>,
+      _runType?: string,
+      runName?: string,
+    ) {
+      const chainName = runName || chain.name || 'unknown_chain';
       const attributes: Record<string, SpanAttributeValue> = {
         [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.ai.langchain',
         'langchain.chain.name': chainName,
diff --git a/packages/node/src/integrations/tracing/postgresjs.ts b/packages/node/src/integrations/tracing/postgresjs.ts
@@ -17,6 +17,8 @@ import {
 } from '@opentelemetry/semantic-conventions';
 import type { IntegrationFn, Span } from '@sentry/core';
 import {
+  _reconstructQuery,
+  _sanitizeSqlQuery,
   debug,
   defineIntegration,
   instrumentPostgresJsSql,
@@ -197,65 +199,6 @@ export class PostgresJsInstrumentation extends InstrumentationBase<PostgresJsIns
     }
   }
 
-  /**
-   * Reconstructs the full SQL query from template strings with PostgreSQL placeholders.
-   *
-   * For sql`SELECT * FROM users WHERE id = ${123} AND name = ${'foo'}`:
-   *   strings = ["SELECT * FROM users WHERE id = ", " AND name = ", ""]
-   *   returns: "SELECT * FROM users WHERE id = $1 AND name = $2"
-   */
-  private _reconstructQuery(strings: string[] | undefined): string | undefined {
-    if (!strings?.length) {
-      return undefined;
-    }
-    if (strings.length === 1) {
-      return strings[0] || undefined;
-    }
-    // Join template parts with PostgreSQL placeholders ($1, $2, etc.)
-    return strings.reduce((acc, str, i) => (i === 0 ? str : `${acc}$${i}${str}`), '');
-  }
-
-  /**
-   * Sanitize SQL query as per the OTEL semantic conventions
-   * https://opentelemetry.io/docs/specs/semconv/database/database-spans/#sanitization-of-dbquerytext
-   *
-   * PostgreSQL $n placeholders are preserved per OTEL spec - they're parameterized queries,
-   * not sensitive literals. Only actual values (strings, numbers, booleans) are sanitized.
-   */
-  private _sanitizeSqlQuery(sqlQuery: string | undefined): string {
-    if (!sqlQuery) {
-      return 'Unknown SQL Query';
-    }
-
-    return (
-      sqlQuery
-        // Remove comments first (they may contain newlines and extra spaces)
-        .replace(/--.*$/gm, '') // Single line comments (multiline mode)
-        .replace(/\/\*[\s\S]*?\*\//g, '') // Multi-line comments
-        .replace(/;\s*$/, '') // Remove trailing semicolons
-        // Collapse whitespace to a single space (after removing comments)
-        .replace(/\s+/g, ' ')
-        .trim() // Remove extra spaces and trim
-        // Sanitize hex/binary literals before string literals
-        .replace(/\bX'[0-9A-Fa-f]*'/gi, '?') // Hex string literals
-        .replace(/\bB'[01]*'/gi, '?') // Binary string literals
-        // Sanitize string literals (handles escaped quotes)
-        .replace(/'(?:[^']|'')*'/g, '?')
-        // Sanitize hex numbers
-        .replace(/\b0x[0-9A-Fa-f]+/gi, '?')
-        // Sanitize boolean literals
-        .replace(/\b(?:TRUE|FALSE)\b/gi, '?')
-        // Sanitize numeric literals (preserve $n placeholders via negative lookbehind)
-        .replace(/-?\b\d+\.?\d*[eE][+-]?\d+\b/g, '?') // Scientific notation
-        .replace(/-?\b\d+\.\d+\b/g, '?') // Decimals
-        .replace(/-?\.\d+\b/g, '?') // Decimals starting with dot
-        .replace(/(?<!\$)-?\b\d+\b/g, '?') // Integers (NOT $n placeholders)
-        // Collapse IN clauses for cardinality (both ? and $n variants)
-        .replace(/\bIN\b\s*\(\s*\?(?:\s*,\s*\?)*\s*\)/gi, 'IN (?)')
-        .replace(/\bIN\b\s*\(\s*\$\d+(?:\s*,\s*\$\d+)*\s*\)/gi, 'IN ($?)')
-    );
-  }
-
   /**
    * Fallback patch for Query.prototype.handle to instrument queries from pre-existing sql instances.
    * This catches queries from sql instances created BEFORE Sentry was initialized (CJS only).
@@ -294,8 +237,8 @@ export class PostgresJsInstrumentation extends InstrumentationBase<PostgresJsIns
         return originalHandle.apply(this, args);
       }
 
-      const fullQuery = self._reconstructQuery(this.strings);
-      const sanitizedSqlQuery = self._sanitizeSqlQuery(fullQuery);
+      const fullQuery = _reconstructQuery(this.strings);
+      const sanitizedSqlQuery = _sanitizeSqlQuery(fullQuery);
 
       return startSpanManual(
         {
diff --git a/packages/node/test/integrations/tracing/postgresjs.test.ts b/packages/node/test/integrations/tracing/postgresjs.test.ts
@@ -1,14 +1,12 @@
+import { _reconstructQuery, _sanitizeSqlQuery } from '@sentry/core';
 import { describe, expect, it } from 'vitest';
 import { PostgresJsInstrumentation } from '../../../src/integrations/tracing/postgresjs';
 
 describe('PostgresJs', () => {
   const instrumentation = new PostgresJsInstrumentation({ requireParentSpan: true });
 
   describe('_reconstructQuery', () => {
-    const reconstruct = (strings: string[] | undefined) =>
-      (
-        instrumentation as unknown as { _reconstructQuery: (s: string[] | undefined) => string | undefined }
-      )._reconstructQuery(strings);
+    const reconstruct = (strings: string[] | undefined) => _reconstructQuery(strings);
 
     describe('empty input handling', () => {
       it.each([
@@ -69,10 +67,7 @@ describe('PostgresJs', () => {
     });
 
     describe('integration with _sanitizeSqlQuery', () => {
-      const sanitize = (query: string | undefined) =>
-        (instrumentation as unknown as { _sanitizeSqlQuery: (q: string | undefined) => string })._sanitizeSqlQuery(
-          query,
-        );
+      const sanitize = (query: string | undefined) => _sanitizeSqlQuery(query);
 
       it('preserves $n placeholders per OTEL spec', () => {
         const strings = ['SELECT * FROM users WHERE id = ', ' AND name = ', ''];
@@ -96,8 +91,7 @@ describe('PostgresJs', () => {
   });
 
   describe('_sanitizeSqlQuery', () => {
-    const sanitize = (query: string | undefined) =>
-      (instrumentation as unknown as { _sanitizeSqlQuery: (q: string | undefined) => string })._sanitizeSqlQuery(query);
+    const sanitize = (query: string | undefined) => _sanitizeSqlQuery(query);
 
     describe('passthrough (no literals)', () => {
       it.each([
