autotel-mongoose 0.0.1

package/src/statement.test.ts

@@ -0,0 +1,78 @@
+import { describe, it, expect } from 'vitest';
+import { defaultSerializer, createStatementCapture } from './statement';
+import type { SerializerPayload } from './types';
+
+describe('defaultSerializer', () => {
+  it('serializes a query condition payload to JSON', () => {
+    const payload: SerializerPayload = {
+      condition: { name: 'Alice' },
+      options: { lean: true },
+    };
+    const result = defaultSerializer('find', payload);
+    expect(result).toBe(JSON.stringify(payload));
+  });
+
+  it('serializes an aggregate pipeline payload', () => {
+    const payload: SerializerPayload = {
+      aggregatePipeline: [{ $match: { status: 'active' } }],
+    };
+    const result = defaultSerializer('aggregate', payload);
+    expect(result).toBe(JSON.stringify(payload));
+  });
+});
+
+describe('createStatementCapture', () => {
+  it('uses default serializer and default redactor when no config provided', () => {
+    const capture = createStatementCapture({
+      dbStatementSerializer: undefined as any,
+      statementRedactor: 'default',
+    });
+    const result = capture('find', {
+      condition: { email: 'test@example.com' },
+    });
+    expect(result).toBeDefined();
+    // Email should be redacted by default preset
+    expect(result).not.toContain('test@example.com');
+    expect(result).toContain('[REDACTED]');
+  });
+
+  it('returns undefined when dbStatementSerializer is false', () => {
+    const capture = createStatementCapture({
+      dbStatementSerializer: false,
+      statementRedactor: 'default',
+    });
+    const result = capture('find', { condition: { name: 'Alice' } });
+    expect(result).toBeUndefined();
+  });
+
+  it('uses custom serializer when provided', () => {
+    const customSerializer = (op: string, _payload: SerializerPayload) =>
+      `custom:${op}`;
+    const capture = createStatementCapture({
+      dbStatementSerializer: customSerializer,
+      statementRedactor: false,
+    });
+    const result = capture('find', { condition: { name: 'Alice' } });
+    expect(result).toBe('custom:find');
+  });
+
+  it('skips redaction when statementRedactor is false', () => {
+    const capture = createStatementCapture({
+      dbStatementSerializer: undefined as any,
+      statementRedactor: false,
+    });
+    const result = capture('find', {
+      condition: { email: 'test@example.com' },
+    });
+    expect(result).toContain('test@example.com');
+  });
+
+  it('returns undefined when custom serializer returns undefined', () => {
+    const capture = createStatementCapture({
+      dbStatementSerializer: () => {},
+      statementRedactor: 'default',
+    });
+    const result = capture('find', { condition: {} });
+    expect(result).toBeUndefined();
+  });
+});

package/src/statement.ts

@@ -0,0 +1,58 @@
+import { createStringRedactor, type StringRedactor } from 'autotel';
+import type { SerializerPayload, InstrumentMongooseConfig } from './types';
+
+/**
+ * Default serializer — JSON.stringify of the payload.
+ */
+export function defaultSerializer(
+  _operation: string,
+  payload: SerializerPayload,
+): string {
+  return JSON.stringify(payload);
+}
+
+export type StatementCaptureFn = (
+  operation: string,
+  payload: SerializerPayload,
+) => string | undefined;
+
+/**
+ * Composes the serializer and redactor into a single capture function.
+ * Returns undefined if statement capture is disabled.
+ */
+export function createStatementCapture(config: {
+  dbStatementSerializer: InstrumentMongooseConfig['dbStatementSerializer'];
+  statementRedactor: InstrumentMongooseConfig['statementRedactor'];
+}): StatementCaptureFn {
+  // Statement capture disabled
+  if (config.dbStatementSerializer === false) {
+    return (): undefined => {
+      return;
+    };
+  }
+
+  const serializer =
+    typeof config.dbStatementSerializer === 'function'
+      ? config.dbStatementSerializer
+      : defaultSerializer;
+
+  // Build redactor (or no-op)
+  let redact: StringRedactor | undefined;
+  if (
+    config.statementRedactor !== false &&
+    config.statementRedactor !== undefined
+  ) {
+    redact = createStringRedactor(config.statementRedactor);
+  }
+
+  return (
+    operation: string,
+    payload: SerializerPayload,
+  ): string | undefined => {
+    const raw = serializer(operation, payload);
+    if (raw === undefined) {
+      return undefined;
+    }
+    return redact ? redact(raw) : raw;
+  };
+}

package/src/test-support.ts

@@ -0,0 +1,32 @@
+import { createServer } from 'node:http';
+
+export async function canListenOnLoopback(): Promise<boolean> {
+  return await new Promise((resolve, reject) => {
+    const server = createServer();
+
+    server.once('error', (error) => {
+      if (
+        error &&
+        typeof error === 'object' &&
+        'code' in error &&
+        error.code === 'EPERM'
+      ) {
+        resolve(false);
+        return;
+      }
+
+      reject(error);
+    });
+
+    server.listen(0, '127.0.0.1', () => {
+      server.close((closeError) => {
+        if (closeError) {
+          reject(closeError);
+          return;
+        }
+
+        resolve(true);
+      });
+    });
+  });
+}

package/src/types.ts

@@ -0,0 +1,74 @@
+import type { AttributeRedactorPreset, AttributeRedactorConfig } from 'autotel';
+
+/**
+ * Payload passed to the dbStatementSerializer.
+ * Shape matches @opentelemetry/instrumentation-mongodb for migration compatibility.
+ */
+export interface SerializerPayload {
+  condition?: Record<string, unknown>;
+  updates?: Record<string, unknown>;
+  options?: Record<string, unknown>;
+  fields?: Record<string, unknown>;
+  aggregatePipeline?: unknown[];
+  document?: unknown;
+  documents?: unknown[];
+  operations?: unknown[];
+}
+
+/**
+ * Configuration for Mongoose instrumentation.
+ */
+export interface InstrumentMongooseConfig {
+  /** Database name for spans (sets db.namespace). */
+  dbName?: string;
+
+  /** MongoDB server hostname (sets server.address). */
+  peerName?: string;
+
+  /** MongoDB server port (sets server.port, default: 27017). */
+  peerPort?: number;
+
+  /** Custom tracer name (default: "autotel-mongoose"). */
+  tracerName?: string;
+
+  /** Capture collection names in spans (default: true). */
+  captureCollectionName?: boolean;
+
+  /** Instrument Schema hooks — pre/post save, validate, etc. (default: false). */
+  instrumentHooks?: boolean;
+
+  /**
+   * Serializer for db.query.text attribute.
+   * Default: JSON.stringify of the payload.
+   * Pass false to disable statement capture entirely.
+   */
+  dbStatementSerializer?:
+    | ((operation: string, payload: SerializerPayload) => string | undefined)
+    | false;
+
+  /**
+   * Redactor applied to serialized statements before setting db.query.text.
+   * Default: 'default' preset (emails, phones, SSNs, credit cards).
+   * Pass a preset name, custom config, or false to disable redaction.
+   */
+  statementRedactor?: AttributeRedactorPreset | AttributeRedactorConfig | false;
+}
+
+/**
+ * Resolved config with all defaults applied.
+ * @internal
+ */
+export interface ResolvedConfig {
+  dbName: string;
+  peerName: string;
+  peerPort: number;
+  tracerName: string;
+  captureCollectionName: boolean;
+  instrumentHooks: boolean;
+  dbStatementSerializer:
+    | ((operation: string, payload: SerializerPayload) => string | undefined)
+    | false;
+  statementRedactor: AttributeRedactorPreset | AttributeRedactorConfig | false;
+}
+
+export const DEFAULT_TRACER_NAME = 'autotel-mongoose';