autotel-drizzle 0.0.34 → 0.0.36

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autotel-drizzle",
-  "version": "0.0.34",
+  "version": "0.0.36",
   "description": "OpenTelemetry instrumentation for Drizzle ORM",
   "type": "module",
   "main": "./dist/drizzle.js",
@@ -15,7 +15,6 @@
   },
   "files": [
     "dist",
-    "src",
     "README.md",
     "skills"
   ],
@@ -37,7 +36,7 @@
     "@opentelemetry/api": "^1.9.1",
     "@opentelemetry/instrumentation": "^0.218.0",
     "@opentelemetry/semantic-conventions": "^1.41.1",
-    "autotel": "4.1.0"
+    "autotel": "4.2.1"
   },
   "peerDependencies": {
     "drizzle-orm": ">=0.45.2"

package/src/common/constants.ts

@@ -1,105 +0,0 @@
-/**
- * OpenTelemetry semantic conventions for database operations.
- * These constants are shared across all plugins.
- */
-
-// Common database attributes
-export const SEMATTRS_DB_SYSTEM = 'db.system' as const;
-export const SEMATTRS_DB_SYSTEM_NAME = 'db.system.name' as const;
-export const SEMATTRS_DB_OPERATION = 'db.operation' as const;
-export const SEMATTRS_DB_STATEMENT = 'db.statement' as const;
-export const SEMATTRS_DB_NAME = 'db.name' as const;
-export const SEMATTRS_DB_NAMESPACE = 'db.namespace' as const;
-export const SEMATTRS_DB_COLLECTION_NAME = 'db.collection.name' as const;
-export const SEMATTRS_DB_OPERATION_NAME = 'db.operation.name' as const;
-export const SEMATTRS_DB_QUERY_TEXT = 'db.query.text' as const;
-export const SEMATTRS_DB_QUERY_SUMMARY = 'db.query.summary' as const;
-/**
- * sha1 hex of the (parameterised, sanitized) statement text. Use to group
- * identical queries in observability tools — the raw `db.statement` is
- * usually unique per call due to inline params or comments, so high-
- * cardinality grouping by it is unhelpful. Example use: aggregate the top
- * 20 queries by total duration by `db.statement.hash`.
- */
-export const SEMATTRS_DB_STATEMENT_HASH = 'db.statement.hash' as const;
-
-// MongoDB-specific attributes
-export const SEMATTRS_DB_MONGODB_COLLECTION = 'db.mongodb.collection' as const;
-
-// Network attributes
-export const SEMATTRS_NET_PEER_NAME = 'net.peer.name' as const;
-export const SEMATTRS_NET_PEER_PORT = 'net.peer.port' as const;
-
-// Messaging attributes (Kafka, etc.)
-export const SEMATTRS_MESSAGING_SYSTEM = 'messaging.system' as const;
-export const SEMATTRS_MESSAGING_DESTINATION_NAME =
-  'messaging.destination.name' as const;
-export const SEMATTRS_MESSAGING_OPERATION = 'messaging.operation' as const;
-export const SEMATTRS_MESSAGING_KAFKA_CONSUMER_GROUP =
-  'messaging.kafka.consumer.group' as const;
-export const SEMATTRS_MESSAGING_KAFKA_PARTITION =
-  'messaging.kafka.partition' as const;
-export const SEMATTRS_MESSAGING_KAFKA_OFFSET =
-  'messaging.kafka.offset' as const;
-export const SEMATTRS_MESSAGING_KAFKA_MESSAGE_KEY =
-  'messaging.kafka.message.key' as const;
-
-// Batch lineage attributes
-export const SEMATTRS_LINKED_TRACE_ID_COUNT = 'linked_trace_id_count' as const;
-export const SEMATTRS_LINKED_TRACE_ID_HASH = 'linked_trace_id_hash' as const;
-
-// Correlation ID header name
-export const CORRELATION_ID_HEADER = 'x-correlation-id' as const;
-
-// BigQuery-specific attributes (namespaced under gcp.bigquery per OTel spec)
-export const SEMATTRS_GCP_BIGQUERY_JOB_ID = 'gcp.bigquery.job.id' as const;
-export const SEMATTRS_GCP_BIGQUERY_JOB_LOCATION =
-  'gcp.bigquery.job.location' as const;
-export const SEMATTRS_GCP_BIGQUERY_PROJECT_ID =
-  'gcp.bigquery.project.id' as const;
-export const SEMATTRS_GCP_BIGQUERY_DESTINATION_TABLE =
-  'gcp.bigquery.destination.table' as const;
-export const SEMATTRS_GCP_BIGQUERY_SOURCE_TABLES =
-  'gcp.bigquery.source.tables' as const;
-export const SEMATTRS_GCP_BIGQUERY_STATEMENT_TYPE =
-  'gcp.bigquery.statement_type' as const;
-export const SEMATTRS_GCP_BIGQUERY_QUERY_HASH =
-  'gcp.bigquery.query.hash' as const;
-export const SEMATTRS_GCP_BIGQUERY_ROWS_AFFECTED =
-  'gcp.bigquery.rows.affected' as const;
-export const SEMATTRS_GCP_BIGQUERY_ROWS_RETURNED =
-  'gcp.bigquery.rows.returned' as const;
-export const SEMATTRS_GCP_BIGQUERY_SCHEMA_FIELDS =
-  'gcp.bigquery.schema.fields' as const;
-
-// RabbitMQ-specific attributes (aligned with OTel messaging semantic conventions)
-export const SEMATTRS_MESSAGING_RABBITMQ_DESTINATION_ROUTING_KEY =
-  'messaging.rabbitmq.destination.routing_key' as const;
-export const SEMATTRS_MESSAGING_RABBITMQ_DESTINATION_EXCHANGE =
-  'messaging.rabbitmq.destination.exchange' as const;
-export const SEMATTRS_MESSAGING_RABBITMQ_ACK_RESULT =
-  'messaging.rabbitmq.ack_result' as const;
-export const SEMATTRS_MESSAGING_RABBITMQ_REQUEUE =
-  'messaging.rabbitmq.requeue' as const;
-
-// Messaging attributes (shared across messaging systems)
-export const SEMATTRS_MESSAGING_MESSAGE_ID = 'messaging.message.id' as const;
-export const SEMATTRS_MESSAGING_MESSAGE_CONVERSATION_ID =
-  'messaging.message.conversation_id' as const;
-export const SEMATTRS_MESSAGING_CONSUMER_ID = 'messaging.consumer.id' as const;
-export const SEMATTRS_MESSAGING_OPERATION_NAME =
-  'messaging.operation.name' as const;
-
-// Kafka batch consumer attributes
-export const SEMATTRS_MESSAGING_BATCH_MESSAGE_COUNT =
-  'messaging.batch.message_count' as const;
-export const SEMATTRS_MESSAGING_KAFKA_BATCH_FIRST_OFFSET =
-  'messaging.kafka.batch.first_offset' as const;
-export const SEMATTRS_MESSAGING_KAFKA_BATCH_LAST_OFFSET =
-  'messaging.kafka.batch.last_offset' as const;
-export const SEMATTRS_MESSAGING_KAFKA_BATCH_MESSAGES_PROCESSED =
-  'messaging.kafka.batch.messages_processed' as const;
-export const SEMATTRS_MESSAGING_KAFKA_BATCH_MESSAGES_FAILED =
-  'messaging.kafka.batch.messages_failed' as const;
-export const SEMATTRS_MESSAGING_KAFKA_BATCH_PROCESSING_TIME_MS =
-  'messaging.kafka.batch.processing_time_ms' as const;

package/src/drizzle/index.test.ts

@@ -1,414 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-
-const spans = vi.hoisted(() => [] as MockSpan[]);
-const tracer = vi.hoisted(() => ({
-  startSpan: vi.fn((name: string, options: unknown) => {
-    const span: MockSpan = {
-      name,
-      options,
-      attributes: {},
-      status: undefined,
-      ended: false,
-      exceptions: [],
-      setAttribute: vi.fn((key: string, value: unknown) => {
-        span.attributes[key] = value;
-      }),
-      setStatus: vi.fn((status: unknown) => {
-        span.status = status;
-      }),
-      recordException: vi.fn((error: unknown) => {
-        span.exceptions.push(error);
-      }),
-      end: vi.fn(() => {
-        span.ended = true;
-      }),
-    };
-
-    spans.push(span);
-    return span;
-  }),
-}));
-const runWithSpan = vi.hoisted(() =>
-  vi.fn((_span: unknown, fn: () => unknown) => fn()),
-);
-const finalizeSpan = vi.hoisted(() =>
-  vi.fn((span: MockSpan, error?: unknown) => {
-    if (error === undefined) {
-      span.setStatus({ code: 'OK' });
-    } else {
-      span.recordException(error);
-      span.setStatus({ code: 'ERROR' });
-    }
-    span.end();
-  }),
-);
-
-vi.mock('@opentelemetry/api', async (importOriginal) => {
-  const actual = await importOriginal<typeof import('@opentelemetry/api')>();
-
-  return {
-    ...actual,
-    trace: {
-      ...actual.trace,
-      getTracer: vi.fn(() => tracer),
-    },
-  };
-});
-
-vi.mock('autotel/trace-helpers', () => ({
-  runWithSpan,
-  finalizeSpan,
-}));
-
-import {
-  instrumentDrizzle,
-  instrumentDrizzleClient,
-  type InstrumentDrizzleConfig,
-} from './index';
-
-interface MockSpan {
-  name: string;
-  options: unknown;
-  attributes: Record<string, unknown>;
-  status: unknown;
-  ended: boolean;
-  exceptions: unknown[];
-  setAttribute: ReturnType<typeof vi.fn>;
-  setStatus: ReturnType<typeof vi.fn>;
-  recordException: ReturnType<typeof vi.fn>;
-  end: ReturnType<typeof vi.fn>;
-}
-
-function getSpan(index = 0): MockSpan {
-  const span = spans[index];
-  expect(span).toBeDefined();
-  return span as MockSpan;
-}
-
-describe('instrumentDrizzle', () => {
-  beforeEach(() => {
-    spans.length = 0;
-    tracer.startSpan.mockClear();
-    runWithSpan.mockClear();
-    finalizeSpan.mockClear();
-  });
-
-  it('preserves synchronous query return values', () => {
-    const client = {
-      query: vi.fn(() => ({ rows: [{ id: 1 }] })),
-    };
-
-    instrumentDrizzle(client);
-
-    const result = client.query('SELECT 1');
-
-    expect(result).toEqual({ rows: [{ id: 1 }] });
-    expect(result).not.toBeInstanceOf(Promise);
-    expect(finalizeSpan).toHaveBeenCalledTimes(1);
-    expect(getSpan().name).toBe('drizzle.select');
-  });
-
-  it('wraps both query and execute when both methods exist', async () => {
-    const client = {
-      query: vi.fn(async () => ({ source: 'query' })),
-      execute: vi.fn(async () => ({ source: 'execute' })),
-    };
-
-    instrumentDrizzle(client);
-    const wrappedQuery = client.query;
-    const wrappedExecute = client.execute;
-
-    instrumentDrizzle(client);
-
-    expect(client.query).toBe(wrappedQuery);
-    expect(client.execute).toBe(wrappedExecute);
-
-    await client.query('SELECT 1');
-    await client.execute({ sql: 'DELETE FROM users' });
-
-    expect(spans).toHaveLength(2);
-    expect(getSpan(0).name).toBe('drizzle.select');
-    expect(getSpan(1).name).toBe('drizzle.delete');
-  });
-
-  it('keeps callback-style clients callback-style', async () => {
-    const client = {
-      query: vi.fn(
-        (
-          _query: string,
-          callback: (error: unknown, result: { ok: true }) => void,
-        ) => {
-          callback(null, { ok: true });
-          return;
-        },
-      ),
-    };
-
-    instrumentDrizzle(client);
-
-    await new Promise<void>((resolve) => {
-      const result = client.query('SELECT 1', (error, payload) => {
-        expect(error).toBeNull();
-        expect(payload).toEqual({ ok: true });
-        resolve();
-      });
-
-      expect(result).toBeUndefined();
-    });
-
-    expect(finalizeSpan).toHaveBeenCalledWith(getSpan(), null);
-  });
-
-  it('records async failures', async () => {
-    const error = new Error('boom');
-    const client = {
-      query: vi.fn(async () => {
-        throw error;
-      }),
-    };
-
-    instrumentDrizzle(client);
-
-    await expect(client.query('SELECT 1')).rejects.toThrow(error);
-
-    expect(getSpan().exceptions).toContain(error);
-    expect(getSpan().status).toEqual({ code: 'ERROR' });
-  });
-
-  it('applies config to captured spans', async () => {
-    const client = {
-      execute: vi.fn(async () => ({ rows: [] })),
-    };
-    const config: InstrumentDrizzleConfig = {
-      dbSystem: 'mysql',
-      dbName: 'app',
-      peerName: 'db.example.com',
-      peerPort: 3306,
-      maxQueryTextLength: 12,
-    };
-
-    instrumentDrizzle(client, config);
-    await client.execute('SELECT * FROM very_long_table_name');
-
-    expect(getSpan().attributes).toMatchObject({
-      'db.system': 'mysql',
-      'db.name': 'app',
-      'net.peer.name': 'db.example.com',
-      'net.peer.port': 3306,
-      'db.operation': 'SELECT',
-      'db.statement': 'SELECT * FRO...',
-    });
-  });
-
-  it('skips db.statement when query capture is disabled', async () => {
-    const client = {
-      query: vi.fn(async () => ({ rows: [] })),
-    };
-
-    instrumentDrizzle(client, { captureQueryText: false });
-    await client.query({ text: 'UPDATE users SET name = $1' });
-
-    expect(getSpan().attributes['db.operation']).toBe('UPDATE');
-    expect(getSpan().attributes['db.statement']).toBeUndefined();
-  });
-
-  it('emits db.statement.hash even when statement text is suppressed', async () => {
-    const client = {
-      query: vi.fn(async () => ({ rows: [] })),
-    };
-
-    instrumentDrizzle(client, { captureQueryText: false });
-    await client.query({ text: 'UPDATE users SET name = $1' });
-
-    const hash = getSpan().attributes['db.statement.hash'];
-    expect(hash).toMatch(/^[0-9a-f]{16}$/);
-  });
-
-  it('produces identical db.statement.hash for identical statements', async () => {
-    const client = {
-      query: vi.fn(async () => ({ rows: [] })),
-    };
-
-    instrumentDrizzle(client, {});
-    await client.query({ text: 'SELECT * FROM users WHERE id = $1' });
-    await client.query({ text: 'SELECT * FROM users WHERE id = $1' });
-
-    expect(getSpan(0).attributes['db.statement.hash']).toBeDefined();
-    expect(getSpan(0).attributes['db.statement.hash']).toBe(
-      getSpan(1).attributes['db.statement.hash'],
-    );
-  });
-
-  it('produces different db.statement.hash for different statements', async () => {
-    const client = {
-      query: vi.fn(async () => ({ rows: [] })),
-    };
-
-    instrumentDrizzle(client, {});
-    await client.query({ text: 'SELECT * FROM users WHERE id = $1' });
-    await client.query({ text: 'SELECT * FROM accounts WHERE id = $1' });
-
-    expect(getSpan(0).attributes['db.statement.hash']).not.toBe(
-      getSpan(1).attributes['db.statement.hash'],
-    );
-  });
-});
-
-describe('instrumentDrizzleClient', () => {
-  beforeEach(() => {
-    spans.length = 0;
-    tracer.startSpan.mockClear();
-    runWithSpan.mockClear();
-    finalizeSpan.mockClear();
-  });
-
-  it('instruments prepared query helper methods, not just execute', () => {
-    const prepared = {
-      all: vi.fn(() => [{ id: 1 }]),
-      get: vi.fn(() => ({ id: 1 })),
-    };
-    const db = {
-      session: {
-        prepareQuery: vi.fn(() => prepared),
-      },
-    };
-
-    instrumentDrizzleClient(db);
-
-    const preparedQuery = db.session.prepareQuery({
-      queryString: 'SELECT * FROM users',
-    });
-
-    const allResult = preparedQuery.all();
-    const getResult = preparedQuery.get();
-
-    expect(allResult).toEqual([{ id: 1 }]);
-    expect(getResult).toEqual({ id: 1 });
-    expect(spans).toHaveLength(2);
-    expect(getSpan(0).attributes['db.statement']).toBe('SELECT * FROM users');
-    expect(getSpan(1).attributes['db.operation']).toBe('SELECT');
-  });
-
-  it('instruments the session but leaves $client untouched', async () => {
-    const originalClientQuery = vi.fn(async () => ({ rows: ['client'] }));
-    const db = {
-      session: {
-        execute: vi.fn(async () => ({ rows: ['session'] })),
-      },
-      $client: {
-        query: originalClientQuery,
-      },
-    };
-
-    instrumentDrizzleClient(db);
-
-    await db.session.execute('INSERT INTO users VALUES (1)');
-    expect(spans).toHaveLength(1);
-    expect(getSpan(0).name).toBe('drizzle.insert');
-
-    // $client.query must remain the original reference. Instrumenting it here
-    // would produce duplicate spans because drizzle's session internally calls
-    // $client.query from within its own already-traced execute path.
-    expect(db.$client.query).toBe(originalClientQuery);
-
-    await db.$client.query('SELECT 1');
-    expect(spans).toHaveLength(1);
-  });
-
-  it('produces one span when drizzle session.prepareQuery routes through the shared $client', async () => {
-    // Simulates the real drizzle-orm/node-postgres flow where
-    // prepared.execute() internally dispatches to db.$client.query().
-    const client = {
-      query: vi.fn(async () => ({ rows: [{ id: 1 }] })),
-    };
-    const db = {
-      $client: client,
-      session: {
-        prepareQuery: vi.fn((query: { sql: string }) => ({
-          execute: vi.fn(async () => client.query(query.sql)),
-        })),
-      },
-    };
-
-    instrumentDrizzleClient(db);
-
-    const prepared = db.session.prepareQuery({ sql: 'SELECT 1' });
-    await prepared.execute();
-
-    // Exactly one autotel span should be created — the one from
-    // instrumented prepared.execute. The inner $client.query call must
-    // NOT create its own span.
-    expect(spans).toHaveLength(1);
-    expect(getSpan(0).name).toBe('drizzle.select');
-    expect(client.query).toHaveBeenCalledTimes(1);
-  });
-
-  it('instruments transaction execute and nested transaction session queries', async () => {
-    let txRef: any;
-    const db = {
-      session: {
-        transaction: vi.fn(async (callback: (tx: unknown) => unknown) => {
-          txRef = {
-            execute: vi.fn(async () => ({ ok: true })),
-            session: {
-              query: vi.fn(async () => ({ ok: true })),
-            },
-          };
-
-          return callback(txRef);
-        }),
-      },
-    };
-
-    instrumentDrizzleClient(db);
-
-    await db.session.transaction(async (tx: any) => {
-      await tx.execute({ sql: 'SET LOCAL role app_user' });
-      await tx.session.query('SELECT 1');
-    });
-
-    expect(spans).toHaveLength(2);
-    expect(getSpan(0).attributes['db.transaction']).toBe(true);
-    expect(getSpan(1).attributes['db.transaction']).toBe(true);
-    expect(txRef.execute).not.toBeUndefined();
-  });
-
-  it('preserves sync execution for fallback _.session.execute', () => {
-    const db = {
-      _: {
-        session: {
-          execute: vi.fn(() => ({ rows: [1] })),
-        },
-      },
-    };
-
-    instrumentDrizzleClient(db);
-
-    const result = db._.session.execute('DELETE FROM users');
-
-    expect(result).toEqual({ rows: [1] });
-    expect(result).not.toBeInstanceOf(Promise);
-    expect(getSpan().name).toBe('drizzle.delete');
-  });
-
-  it('is idempotent when called repeatedly', () => {
-    const originalClientExecute = vi.fn(async () => ({ rows: [] }));
-    const db = {
-      session: {
-        query: vi.fn(async () => ({ rows: [] })),
-      },
-      $client: {
-        execute: originalClientExecute,
-      },
-    };
-
-    instrumentDrizzleClient(db);
-    const firstSessionQuery = db.session.query;
-
-    instrumentDrizzleClient(db);
-
-    expect(db.session.query).toBe(firstSessionQuery);
-    // $client.execute is intentionally not wrapped by instrumentDrizzleClient.
-    expect(db.$client.execute).toBe(originalClientExecute);
-  });
-});

package/src/drizzle/index.ts

@@ -1,552 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { createHash } from 'node:crypto';
-import { SpanKind, trace } from '@opentelemetry/api';
-import {
-  SEMATTRS_DB_NAME,
-  SEMATTRS_DB_OPERATION,
-  SEMATTRS_DB_STATEMENT,
-  SEMATTRS_DB_STATEMENT_HASH,
-  SEMATTRS_DB_SYSTEM,
-  SEMATTRS_NET_PEER_NAME,
-  SEMATTRS_NET_PEER_PORT,
-} from '../common/constants';
-import { finalizeSpan, runWithSpan } from 'autotel/trace-helpers';
-
-const DEFAULT_TRACER_NAME = 'autotel-plugins/drizzle';
-const DEFAULT_DB_SYSTEM = 'postgresql';
-const INSTRUMENTED_FLAG = '__autotelDrizzleInstrumented' as const;
-const PREPARED_QUERY_METHODS = [
-  'all',
-  'execute',
-  'get',
-  'run',
-  'values',
-] as const;
-
-type QueryCallback = (error: unknown, result: unknown) => void;
-type QueryFunction = (...args: any[]) => any;
-type AttributeValue = string | number | boolean;
-type AttributeMap = Record<string, AttributeValue>;
-
-interface InstrumentableObject {
-  [key: string]: any;
-  [INSTRUMENTED_FLAG]?: true;
-}
-
-interface DrizzleClientLike extends InstrumentableObject {
-  query?: QueryFunction;
-  execute?: QueryFunction;
-}
-
-interface DrizzleSessionLike extends InstrumentableObject {
-  query?: QueryFunction;
-  execute?: QueryFunction;
-  prepareQuery?: QueryFunction;
-  transaction?: QueryFunction;
-}
-
-interface DrizzleDbLike extends InstrumentableObject {
-  $client?: DrizzleClientLike;
-  session?: DrizzleSessionLike;
-  _?: {
-    session?: DrizzleSessionLike;
-    [key: string]: any;
-  };
-}
-
-export interface InstrumentDrizzleConfig {
-  tracerName?: string;
-  dbSystem?: string;
-  dbName?: string;
-  captureQueryText?: boolean;
-  maxQueryTextLength?: number;
-  peerName?: string;
-  peerPort?: number;
-}
-
-interface ResolvedConfig {
-  tracerName: string;
-  dbSystem: string;
-  dbName?: string;
-  captureQueryText: boolean;
-  maxQueryTextLength: number;
-  peerName?: string;
-  peerPort?: number;
-}
-
-interface InstrumentationState {
-  tracer: ReturnType<typeof trace.getTracer>;
-  config: ResolvedConfig;
-}
-
-interface MethodInstrumentationOptions {
-  flagSuffix: string;
-  queryText: (args: any[]) => string | undefined;
-  callbackStyle?: 'last-arg';
-  extraAttributes?: AttributeMap;
-}
-
-function resolveConfig(config?: InstrumentDrizzleConfig): ResolvedConfig {
-  return {
-    tracerName: config?.tracerName ?? DEFAULT_TRACER_NAME,
-    dbSystem: config?.dbSystem ?? DEFAULT_DB_SYSTEM,
-    dbName: config?.dbName,
-    captureQueryText: config?.captureQueryText ?? true,
-    maxQueryTextLength: config?.maxQueryTextLength ?? 1000,
-    peerName: config?.peerName,
-    peerPort: config?.peerPort,
-  };
-}
-
-function getState(config?: InstrumentDrizzleConfig): InstrumentationState {
-  const resolved = resolveConfig(config);
-  return {
-    config: resolved,
-    tracer: trace.getTracer(resolved.tracerName),
-  };
-}
-
-function getFlagKey(suffix: string): string {
-  return `${INSTRUMENTED_FLAG}:${suffix}`;
-}
-
-function isObject(value: unknown): value is InstrumentableObject {
-  return value !== null && typeof value === 'object';
-}
-
-function isPromiseLike<T>(value: T | PromiseLike<T>): value is PromiseLike<T> {
-  return (
-    typeof value === 'object' &&
-    value !== null &&
-    typeof (value as PromiseLike<T>).then === 'function'
-  );
-}
-
-function extractQueryText(queryArg: unknown): string | undefined {
-  if (typeof queryArg === 'string') {
-    return queryArg;
-  }
-
-  if (!isObject(queryArg)) {
-    return undefined;
-  }
-
-  if (typeof queryArg.sql === 'string') {
-    return queryArg.sql;
-  }
-
-  if (typeof queryArg.text === 'string') {
-    return queryArg.text;
-  }
-
-  if (typeof queryArg.queryString === 'string') {
-    return queryArg.queryString;
-  }
-
-  if (
-    isObject(queryArg.queryChunks) &&
-    typeof (queryArg as Record<string, unknown>).sql === 'string'
-  ) {
-    return queryArg.sql as string;
-  }
-
-  return undefined;
-}
-
-function sanitizeQueryText(queryText: string, maxLength: number): string {
-  if (queryText.length <= maxLength) {
-    return queryText;
-  }
-
-  return `${queryText.slice(0, Math.max(0, maxLength))}...`;
-}
-
-/**
- * Stable sha1 of a parameterised SQL statement, used as `db.statement.hash`.
- * Hashes the full original text (not the truncated form) so the hash is
- * identical for queries that only differ in trailing length. We keep this
- * cheap (sha1, hex, take 16 chars) — the goal is grouping, not crypto.
- */
-function hashQueryText(queryText: string): string {
-  return createHash('sha1').update(queryText).digest('hex').slice(0, 16);
-}
-
-function extractOperation(queryText: string): string | undefined {
-  const trimmed = queryText.trimStart();
-  const match = /^(?<operation>\w+)/u.exec(trimmed);
-  return match?.groups?.operation?.toUpperCase();
-}
-
-function buildSpan(
-  state: InstrumentationState,
-  queryText: string | undefined,
-  extraAttributes?: AttributeMap,
-) {
-  const operation = queryText ? extractOperation(queryText) : undefined;
-  const spanName = operation
-    ? `drizzle.${operation.toLowerCase()}`
-    : 'drizzle.query';
-  const span = state.tracer.startSpan(spanName, { kind: SpanKind.CLIENT });
-
-  span.setAttribute(SEMATTRS_DB_SYSTEM, state.config.dbSystem);
-
-  if (operation) {
-    span.setAttribute(SEMATTRS_DB_OPERATION, operation);
-  }
-
-  if (state.config.dbName !== undefined) {
-    span.setAttribute(SEMATTRS_DB_NAME, state.config.dbName);
-  }
-
-  if (queryText !== undefined) {
-    // The hash always lives on the span — even when captureQueryText is off
-    // (e.g. for privacy / size reasons) — so query grouping still works.
-    span.setAttribute(SEMATTRS_DB_STATEMENT_HASH, hashQueryText(queryText));
-  }
-
-  if (state.config.captureQueryText && queryText !== undefined) {
-    span.setAttribute(
-      SEMATTRS_DB_STATEMENT,
-      sanitizeQueryText(queryText, state.config.maxQueryTextLength),
-    );
-  }
-
-  if (state.config.peerName !== undefined) {
-    span.setAttribute(SEMATTRS_NET_PEER_NAME, state.config.peerName);
-  }
-
-  if (state.config.peerPort !== undefined) {
-    span.setAttribute(SEMATTRS_NET_PEER_PORT, state.config.peerPort);
-  }
-
-  if (extraAttributes) {
-    for (const [key, value] of Object.entries(extraAttributes)) {
-      span.setAttribute(key, value);
-    }
-  }
-
-  return span;
-}
-
-function executeWithSpan<T>(span: any, fn: () => T): T {
-  return runWithSpan(span, () => {
-    try {
-      const result = fn();
-
-      if (isPromiseLike(result)) {
-        return result.then(
-          (value) => {
-            finalizeSpan(span);
-            return value;
-          },
-          (error) => {
-            finalizeSpan(span, error);
-            throw error;
-          },
-        ) as T;
-      }
-
-      finalizeSpan(span);
-      return result;
-    } catch (error) {
-      finalizeSpan(span, error);
-      throw error;
-    }
-  });
-}
-
-function instrumentMethod(
-  target: InstrumentableObject,
-  methodName: string,
-  state: InstrumentationState,
-  options: MethodInstrumentationOptions,
-): boolean {
-  if (typeof target[methodName] !== 'function') {
-    return false;
-  }
-
-  const flagKey = getFlagKey(options.flagSuffix);
-  if (target[flagKey]) {
-    return false;
-  }
-
-  const originalMethod = target[methodName] as QueryFunction;
-
-  target[methodName] = function instrumentedMethod(
-    this: any,
-    ...incomingArgs: any[]
-  ) {
-    const args = [...incomingArgs];
-    const callback =
-      options.callbackStyle === 'last-arg' && typeof args.at(-1) === 'function'
-        ? (args.pop() as QueryCallback)
-        : undefined;
-    const span = buildSpan(
-      state,
-      options.queryText(args),
-      options.extraAttributes,
-    );
-
-    if (callback) {
-      return runWithSpan(span, () => {
-        const wrappedCallback: QueryCallback = (error, result) => {
-          finalizeSpan(span, error);
-          callback(error, result);
-        };
-
-        try {
-          return Reflect.apply(originalMethod, this, [
-            ...args,
-            wrappedCallback,
-          ]);
-        } catch (error) {
-          finalizeSpan(span, error);
-          throw error;
-        }
-      });
-    }
-
-    return executeWithSpan(span, () =>
-      Reflect.apply(originalMethod, this, args),
-    );
-  };
-
-  target[flagKey] = true;
-  return true;
-}
-
-function instrumentPreparedQuery(
-  prepared: unknown,
-  state: InstrumentationState,
-  querySource: unknown,
-  extraAttributes?: AttributeMap,
-): boolean {
-  if (!isObject(prepared)) {
-    return false;
-  }
-
-  let instrumented = false;
-  const queryText = extractQueryText(querySource);
-
-  for (const methodName of PREPARED_QUERY_METHODS) {
-    instrumented =
-      instrumentMethod(prepared, methodName, state, {
-        flagSuffix: `prepared:${methodName}`,
-        queryText: () => queryText,
-        extraAttributes,
-      }) || instrumented;
-  }
-
-  return instrumented;
-}
-
-function instrumentPrepareQuery(
-  target: DrizzleSessionLike,
-  state: InstrumentationState,
-  extraAttributes?: AttributeMap,
-): boolean {
-  if (typeof target.prepareQuery !== 'function') {
-    return false;
-  }
-
-  const flagKey = getFlagKey('prepareQuery');
-  if (target[flagKey]) {
-    return false;
-  }
-
-  const originalPrepareQuery = target.prepareQuery;
-
-  target.prepareQuery = function instrumentedPrepareQuery(
-    this: any,
-    ...prepareArgs: any[]
-  ) {
-    const prepared = Reflect.apply(originalPrepareQuery, this, prepareArgs);
-    instrumentPreparedQuery(prepared, state, prepareArgs[0], extraAttributes);
-    return prepared;
-  };
-
-  target[flagKey] = true;
-  return true;
-}
-
-function instrumentTransactionTarget(
-  target: unknown,
-  state: InstrumentationState,
-): boolean {
-  if (!isObject(target)) {
-    return false;
-  }
-
-  const transactionAttributes = { 'db.transaction': true };
-  let instrumented = false;
-
-  instrumented =
-    instrumentMethod(target, 'query', state, {
-      flagSuffix: 'transaction:query',
-      queryText: (args) => extractQueryText(args[0]),
-      callbackStyle: 'last-arg',
-      extraAttributes: transactionAttributes,
-    }) || instrumented;
-
-  instrumented =
-    instrumentMethod(target, 'execute', state, {
-      flagSuffix: 'transaction:execute',
-      queryText: (args) => extractQueryText(args[0]),
-      callbackStyle: 'last-arg',
-      extraAttributes: transactionAttributes,
-    }) || instrumented;
-
-  instrumented =
-    instrumentPrepareQuery(
-      target as DrizzleSessionLike,
-      state,
-      transactionAttributes,
-    ) || instrumented;
-
-  if (isObject(target.session)) {
-    instrumented =
-      instrumentTransactionTarget(target.session, state) || instrumented;
-  }
-
-  if (isObject(target._?.session)) {
-    instrumented =
-      instrumentTransactionTarget(target._.session, state) || instrumented;
-  }
-
-  return instrumented;
-}
-
-function instrumentSession(
-  session: DrizzleSessionLike,
-  state: InstrumentationState,
-): boolean {
-  let instrumented = false;
-
-  instrumented =
-    instrumentMethod(session, 'query', state, {
-      flagSuffix: 'session:query',
-      queryText: (args) => extractQueryText(args[0]),
-      callbackStyle: 'last-arg',
-    }) || instrumented;
-
-  instrumented =
-    instrumentMethod(session, 'execute', state, {
-      flagSuffix: 'session:execute',
-      queryText: (args) => extractQueryText(args[0]),
-      callbackStyle: 'last-arg',
-    }) || instrumented;
-
-  instrumented = instrumentPrepareQuery(session, state) || instrumented;
-
-  if (typeof session.transaction === 'function') {
-    const flagKey = getFlagKey('session:transaction');
-
-    if (!session[flagKey]) {
-      const originalTransaction = session.transaction;
-
-      session.transaction = function instrumentedTransaction(
-        this: any,
-        callback: QueryFunction,
-        ...restArgs: any[]
-      ) {
-        if (typeof callback !== 'function') {
-          return Reflect.apply(originalTransaction, this, [
-            callback,
-            ...restArgs,
-          ]);
-        }
-
-        const wrappedCallback = (tx: unknown, ...callbackArgs: any[]) => {
-          instrumentTransactionTarget(tx, state);
-          return Reflect.apply(callback, this, [tx, ...callbackArgs]);
-        };
-
-        return Reflect.apply(originalTransaction, this, [
-          wrappedCallback,
-          ...restArgs,
-        ]);
-      };
-
-      session[flagKey] = true;
-      instrumented = true;
-    }
-  }
-
-  if (instrumented) {
-    session[INSTRUMENTED_FLAG] = true;
-  }
-
-  return instrumented;
-}
-
-export function instrumentDrizzle<TClient extends DrizzleClientLike>(
-  client: TClient,
-  config?: InstrumentDrizzleConfig,
-): TClient {
-  if (!client || !isObject(client)) {
-    return client;
-  }
-
-  const state = getState(config);
-  let instrumented = false;
-
-  instrumented =
-    instrumentMethod(client, 'query', state, {
-      flagSuffix: 'client:query',
-      queryText: (args) => extractQueryText(args[0]),
-      callbackStyle: 'last-arg',
-    }) || instrumented;
-
-  instrumented =
-    instrumentMethod(client, 'execute', state, {
-      flagSuffix: 'client:execute',
-      queryText: (args) => extractQueryText(args[0]),
-      callbackStyle: 'last-arg',
-    }) || instrumented;
-
-  if (instrumented) {
-    client[INSTRUMENTED_FLAG] = true;
-  }
-
-  return client;
-}
-
-export function instrumentDrizzleClient<TDb extends DrizzleDbLike>(
-  db: TDb,
-  config?: InstrumentDrizzleConfig,
-): TDb {
-  if (!db || !isObject(db)) {
-    return db;
-  }
-
-  if (db[INSTRUMENTED_FLAG]) {
-    return db;
-  }
-
-  const state = getState(config);
-  let instrumented = false;
-
-  instrumented =
-    instrumentSession(db as unknown as DrizzleSessionLike, state) ||
-    instrumented;
-
-  if (isObject(db.session)) {
-    instrumented = instrumentSession(db.session, state) || instrumented;
-  }
-
-  if (isObject(db._?.session)) {
-    instrumented = instrumentSession(db._.session, state) || instrumented;
-  }
-
-  // Intentionally do NOT instrument db.$client here. The raw client (e.g.
-  // pg.Pool) is the same object that drizzle's session invokes internally from
-  // its prepared query's execute(). Wrapping both layers produces nested
-  // duplicate spans for every query. Users who need to trace a standalone
-  // client without a drizzle wrapper should call `instrumentDrizzle` directly.
-
-  if (instrumented) {
-    db[INSTRUMENTED_FLAG] = true;
-  }
-
-  return db;
-}

package/src/index.ts

@@ -1,64 +0,0 @@
-/**
- * Autotel Drizzle - OpenTelemetry instrumentation for Drizzle ORM
- *
- * This package provides instrumentation for Drizzle ORM.
- *
- * Philosophy:
- * Only include plugins for libraries that either:
- * 1. Have NO official instrumentation (e.g., Drizzle ORM)
- * 2. Have BROKEN official instrumentation (e.g., Mongoose in ESM+tsx)
- * 3. Add SIGNIFICANT value beyond official packages (e.g., Kafka processing spans)
- *
- * For databases/ORMs with working official instrumentation, use those directly with the --import pattern:
- * - MongoDB: @opentelemetry/instrumentation-mongodb
- * - PostgreSQL: @opentelemetry/instrumentation-pg
- * - MySQL: @opentelemetry/instrumentation-mysql2
- * - Redis: @opentelemetry/instrumentation-redis
- * - Kafka: @opentelemetry/instrumentation-kafkajs (use with autotel-plugins/kafka for processing spans)
- *
- * See: https://github.com/open-telemetry/opentelemetry-js-contrib
- *
- * @example
- * ```typescript
- * // Drizzle manual instrumentation
- * import { instrumentDrizzleClient } from 'autotel-drizzle';
- * import { drizzle } from 'drizzle-orm/node-postgres';
- *
- * const db = instrumentDrizzleClient(drizzle(pool));
- * ```
- *
- * @packageDocumentation
- */
-
-// Re-export common semantic conventions
-export {
-  SEMATTRS_DB_SYSTEM,
-  SEMATTRS_DB_SYSTEM_NAME,
-  SEMATTRS_DB_OPERATION,
-  SEMATTRS_DB_OPERATION_NAME,
-  SEMATTRS_DB_STATEMENT,
-  SEMATTRS_DB_NAME,
-  SEMATTRS_DB_NAMESPACE,
-  SEMATTRS_DB_COLLECTION_NAME,
-  SEMATTRS_DB_QUERY_TEXT,
-  SEMATTRS_DB_QUERY_SUMMARY,
-  SEMATTRS_NET_PEER_NAME,
-  SEMATTRS_NET_PEER_PORT,
-  SEMATTRS_GCP_BIGQUERY_JOB_ID,
-  SEMATTRS_GCP_BIGQUERY_JOB_LOCATION,
-  SEMATTRS_GCP_BIGQUERY_PROJECT_ID,
-  SEMATTRS_GCP_BIGQUERY_DESTINATION_TABLE,
-  SEMATTRS_GCP_BIGQUERY_SOURCE_TABLES,
-  SEMATTRS_GCP_BIGQUERY_STATEMENT_TYPE,
-  SEMATTRS_GCP_BIGQUERY_QUERY_HASH,
-  SEMATTRS_GCP_BIGQUERY_ROWS_AFFECTED,
-  SEMATTRS_GCP_BIGQUERY_ROWS_RETURNED,
-  SEMATTRS_GCP_BIGQUERY_SCHEMA_FIELDS,
-} from './common/constants';
-
-// Re-export Drizzle plugin
-export {
-  instrumentDrizzle,
-  instrumentDrizzleClient,
-  type InstrumentDrizzleConfig,
-} from './drizzle';