autotel-mongoose 0.0.1

package/dist/index.js

@@ -0,0 +1,594 @@
+import { otelTrace, createStringRedactor, SpanKind } from 'autotel';
+import { runWithSpan, finalizeSpan, getActiveSpan } from 'autotel/trace-helpers';
+
+// src/instrumentation.ts
+
+// src/constants.ts
+var ATTR_DB_QUERY_TEXT = "db.query.text";
+var ATTR_DB_OPERATION_NAME = "db.operation.name";
+var ATTR_DB_SYSTEM_NAME = "db.system.name";
+var ATTR_DB_COLLECTION_NAME = "db.collection.name";
+var ATTR_DB_NAMESPACE = "db.namespace";
+var ATTR_SERVER_ADDRESS = "server.address";
+var ATTR_SERVER_PORT = "server.port";
+var DB_SYSTEM_NAME_VALUE_MONGODB = "mongodb";
+
+// src/types.ts
+var DEFAULT_TRACER_NAME = "autotel-mongoose";
+function defaultSerializer(_operation, payload) {
+  return JSON.stringify(payload);
+}
+function createStatementCapture(config) {
+  if (config.dbStatementSerializer === false) {
+    return () => {
+      return;
+    };
+  }
+  const serializer = typeof config.dbStatementSerializer === "function" ? config.dbStatementSerializer : defaultSerializer;
+  let redact;
+  if (config.statementRedactor !== false && config.statementRedactor !== void 0) {
+    redact = createStringRedactor(config.statementRedactor);
+  }
+  return (operation, payload) => {
+    const raw = serializer(operation, payload);
+    if (raw === void 0) {
+      return void 0;
+    }
+    return redact ? redact(raw) : raw;
+  };
+}
+
+// src/instrumentation.ts
+var INSTRUMENTED_FLAG = "__autotelMongooseInstrumented";
+var WRAPPED_HOOK_FLAG = "__autotelWrappedHook";
+var _STORED_PARENT_SPAN = /* @__PURE__ */ Symbol("stored-parent-span");
+function createSpan(tracer, operation, modelName, collectionName, config) {
+  const spanName = collectionName ? `${operation} ${collectionName}` : modelName ? `${operation} ${modelName}` : `mongoose.${operation}`;
+  const attributes = {
+    [ATTR_DB_SYSTEM_NAME]: DB_SYSTEM_NAME_VALUE_MONGODB,
+    [ATTR_DB_OPERATION_NAME]: operation
+  };
+  if (collectionName && config.captureCollectionName) {
+    attributes[ATTR_DB_COLLECTION_NAME] = collectionName;
+  }
+  if (config.dbName) {
+    attributes[ATTR_DB_NAMESPACE] = config.dbName;
+  }
+  if (config.peerName) {
+    attributes[ATTR_SERVER_ADDRESS] = config.peerName;
+  }
+  if (config.peerPort) {
+    attributes[ATTR_SERVER_PORT] = config.peerPort;
+  }
+  return tracer.startSpan(spanName, { kind: SpanKind.CLIENT, attributes });
+}
+function wrapQueryReturningMethod(target, methodName, operation, getCollectionName, getModelName, tracer, config, captureStatement) {
+  const original = target[methodName];
+  if (typeof original !== "function") {
+    return;
+  }
+  target[methodName] = function instrumented(...args) {
+    const collectionName = getCollectionName(this);
+    const modelName = getModelName(this);
+    const span = createSpan(
+      tracer,
+      operation,
+      modelName,
+      collectionName,
+      config
+    );
+    return runWithSpan(span, () => {
+      try {
+        const result = original.apply(this, args);
+        if (result && typeof result.exec === "function") {
+          try {
+            const payload = {};
+            if (typeof result.getFilter === "function") {
+              payload.condition = result.getFilter();
+            }
+            if (result._update !== void 0) {
+              payload.updates = result._update;
+            }
+            if (typeof result.getOptions === "function") {
+              payload.options = result.getOptions();
+            }
+            if (result._fields !== void 0) {
+              payload.fields = result._fields;
+            }
+            const statementText = captureStatement(operation, payload);
+            if (statementText) {
+              span.setAttribute(ATTR_DB_QUERY_TEXT, statementText);
+            }
+          } catch {
+          }
+          const originalExec = result.exec.bind(result);
+          result.exec = function wrappedExec() {
+            try {
+              const execPromise = originalExec();
+              return Promise.resolve(execPromise).then((value) => {
+                finalizeSpan(span);
+                return value;
+              }).catch((error) => {
+                finalizeSpan(
+                  span,
+                  error instanceof Error ? error : new Error(String(error))
+                );
+                throw error;
+              });
+            } catch (error) {
+              finalizeSpan(
+                span,
+                error instanceof Error ? error : new Error(String(error))
+              );
+              throw error;
+            }
+          };
+          return result;
+        }
+        finalizeSpan(span);
+        return result;
+      } catch (error) {
+        finalizeSpan(
+          span,
+          error instanceof Error ? error : new Error(String(error))
+        );
+        throw error;
+      }
+    });
+  };
+}
+function wrapStaticMethod(target, methodName, operation, getCollectionName, getModelName, tracer, config, captureStatement) {
+  const original = target[methodName];
+  if (typeof original !== "function") {
+    return;
+  }
+  target[methodName] = function instrumented(...args) {
+    const collectionName = getCollectionName(this);
+    const modelName = getModelName(this);
+    const payload = {};
+    try {
+      switch (operation) {
+        case "create": {
+          payload.document = args[0];
+          break;
+        }
+        case "insertMany": {
+          payload.documents = args[0];
+          break;
+        }
+        case "aggregate": {
+          payload.aggregatePipeline = args[0];
+          break;
+        }
+        case "bulkWrite": {
+          payload.operations = args[0];
+          break;
+        }
+        default: {
+          break;
+        }
+      }
+    } catch {
+    }
+    const span = createSpan(
+      tracer,
+      operation,
+      modelName,
+      collectionName,
+      config
+    );
+    try {
+      const statementText = captureStatement(operation, payload);
+      if (statementText) {
+        span.setAttribute(ATTR_DB_QUERY_TEXT, statementText);
+      }
+    } catch {
+    }
+    return runWithSpan(span, () => {
+      try {
+        const result = original.apply(this, args);
+        if (result && typeof result.exec === "function") {
+          const originalExec = result.exec.bind(result);
+          result.exec = function wrappedExec() {
+            try {
+              const execPromise = originalExec();
+              return Promise.resolve(execPromise).then((value) => {
+                finalizeSpan(span);
+                return value;
+              }).catch((error) => {
+                finalizeSpan(
+                  span,
+                  error instanceof Error ? error : new Error(String(error))
+                );
+                throw error;
+              });
+            } catch (error) {
+              finalizeSpan(
+                span,
+                error instanceof Error ? error : new Error(String(error))
+              );
+              throw error;
+            }
+          };
+          return result;
+        }
+        if (result && typeof result.then === "function") {
+          return Promise.resolve(result).then((value) => {
+            finalizeSpan(span);
+            return value;
+          }).catch((error) => {
+            finalizeSpan(
+              span,
+              error instanceof Error ? error : new Error(String(error))
+            );
+            throw error;
+          });
+        }
+        finalizeSpan(span);
+        return result;
+      } catch (error) {
+        finalizeSpan(
+          span,
+          error instanceof Error ? error : new Error(String(error))
+        );
+        throw error;
+      }
+    });
+  };
+}
+function wrapInstanceMethod(target, methodName, operation, getCollectionName, getModelName, tracer, config, captureStatement) {
+  const original = target[methodName];
+  if (typeof original !== "function") {
+    return;
+  }
+  target[methodName] = function instrumented(...args) {
+    const collectionName = getCollectionName(this);
+    const modelName = getModelName(this);
+    const payload = {};
+    try {
+      if (typeof this.toObject === "function") {
+        payload.document = this.toObject();
+      }
+    } catch {
+    }
+    const span = createSpan(
+      tracer,
+      operation,
+      modelName,
+      collectionName,
+      config
+    );
+    try {
+      const statementText = captureStatement(operation, payload);
+      if (statementText) {
+        span.setAttribute(ATTR_DB_QUERY_TEXT, statementText);
+      }
+    } catch {
+    }
+    return runWithSpan(span, () => {
+      try {
+        const result = original.apply(this, args);
+        if (result && typeof result.then === "function") {
+          return Promise.resolve(result).then((value) => {
+            finalizeSpan(span);
+            return value;
+          }).catch((error) => {
+            finalizeSpan(
+              span,
+              error instanceof Error ? error : new Error(String(error))
+            );
+            throw error;
+          });
+        }
+        finalizeSpan(span);
+        return result;
+      } catch (error) {
+        finalizeSpan(
+          span,
+          error instanceof Error ? error : new Error(String(error))
+        );
+        throw error;
+      }
+    });
+  };
+}
+function wrapChainableMethod(target, methodName) {
+  const original = target[methodName];
+  if (typeof original !== "function") {
+    return;
+  }
+  target[methodName] = function captureContext(...args) {
+    const currentSpan = getActiveSpan();
+    const result = original.apply(this, args);
+    if (result && typeof result.exec === "function") {
+      result[_STORED_PARENT_SPAN] = currentSpan;
+    }
+    return result;
+  };
+}
+function patchSchemaHooks(Schema, tracer, config) {
+  if (!Schema?.prototype) {
+    return;
+  }
+  const HOOK_FLAG = "__autotelHookInstrumented";
+  if (Schema.prototype[HOOK_FLAG]) {
+    return;
+  }
+  const originalPre = Schema.prototype.pre;
+  if (typeof originalPre === "function") {
+    Schema.prototype.pre = function(hookName, ...args) {
+      const handler = typeof args[0] === "function" ? args[0] : typeof args[1] === "function" ? args[1] : null;
+      if (handler && !isMongooseInternalHook(handler)) {
+        const wrapped = wrapHookHandler(
+          handler,
+          hookName,
+          "pre",
+          tracer,
+          config
+        );
+        if (typeof args[0] === "function") {
+          args[0] = wrapped;
+        } else if (typeof args[1] === "function") {
+          args[1] = wrapped;
+        }
+      }
+      return Reflect.apply(originalPre, this, [hookName, ...args]);
+    };
+  }
+  const originalPost = Schema.prototype.post;
+  if (typeof originalPost === "function") {
+    Schema.prototype.post = function(hookName, ...args) {
+      const handler = typeof args[0] === "function" ? args[0] : typeof args[1] === "function" ? args[1] : null;
+      if (handler && !isMongooseInternalHook(handler)) {
+        const wrapped = wrapHookHandler(
+          handler,
+          hookName,
+          "post",
+          tracer,
+          config
+        );
+        if (typeof args[0] === "function") {
+          args[0] = wrapped;
+        } else if (typeof args[1] === "function") {
+          args[1] = wrapped;
+        }
+      }
+      return Reflect.apply(originalPost, this, [hookName, ...args]);
+    };
+  }
+  Schema.prototype[HOOK_FLAG] = true;
+}
+function isMongooseInternalHook(handler) {
+  if (typeof handler !== "function") {
+    return false;
+  }
+  const funcName = handler.name || "";
+  if (funcName.startsWith("_") || funcName.startsWith("$")) {
+    return true;
+  }
+  const mongooseInternalNamePatterns = [
+    "shardingPlugin",
+    "mongooseInternalHook",
+    "noop",
+    "wrapped",
+    "bound "
+  ];
+  if (mongooseInternalNamePatterns.some((pattern) => funcName.includes(pattern))) {
+    return true;
+  }
+  try {
+    const source = handler.toString();
+    const mongooseInternalSourcePatterns = [
+      "this.$__",
+      // Mongoose internal document methods
+      "this.$isValid",
+      // Mongoose validation
+      "this.$locals",
+      // Mongoose local properties
+      "_this.$__",
+      // Mongoose internal with closure
+      "schema.s.hooks",
+      // Mongoose hooks system
+      "kareem"
+      // Mongoose's hooks library
+    ];
+    if (mongooseInternalSourcePatterns.some((pattern) => source.includes(pattern))) {
+      return true;
+    }
+  } catch {
+  }
+  return false;
+}
+function wrapHookHandler(handler, hookName, hookType, tracer, config) {
+  if (typeof handler !== "function") {
+    return handler;
+  }
+  if (handler[WRAPPED_HOOK_FLAG]) {
+    return handler;
+  }
+  const wrappedHook = function wrappedHook2(...args) {
+    let modelName;
+    let collectionName;
+    try {
+      if (this.constructor?.modelName) {
+        modelName = this.constructor.modelName;
+        collectionName = this.constructor.collection?.collectionName || modelName;
+      } else if (this.model?.modelName) {
+        modelName = this.model.modelName;
+        collectionName = this.model.collection?.collectionName || modelName;
+      }
+    } catch {
+    }
+    const spanName = collectionName ? `mongoose.${collectionName}.${hookType}.${hookName}` : `mongoose.hook.${hookType}.${hookName}`;
+    const span = tracer.startSpan(spanName, { kind: SpanKind.INTERNAL });
+    span.setAttribute("hook.type", hookType);
+    span.setAttribute("hook.operation", hookName);
+    if (modelName) {
+      span.setAttribute("hook.model", modelName);
+    }
+    if (collectionName && config.captureCollectionName) {
+      span.setAttribute(ATTR_DB_COLLECTION_NAME, collectionName);
+    }
+    span.setAttribute(ATTR_DB_SYSTEM_NAME, DB_SYSTEM_NAME_VALUE_MONGODB);
+    if (config.dbName) {
+      span.setAttribute(ATTR_DB_NAMESPACE, config.dbName);
+    }
+    return runWithSpan(span, () => {
+      try {
+        const result = handler.apply(this, args);
+        if (result && typeof result.then === "function") {
+          return Promise.resolve(result).then((value) => {
+            finalizeSpan(span);
+            return value;
+          }).catch((error) => {
+            finalizeSpan(
+              span,
+              error instanceof Error ? error : new Error(String(error))
+            );
+            throw error;
+          });
+        }
+        finalizeSpan(span);
+        return result;
+      } catch (error) {
+        finalizeSpan(
+          span,
+          error instanceof Error ? error : new Error(String(error))
+        );
+        throw error;
+      }
+    });
+  };
+  wrappedHook[WRAPPED_HOOK_FLAG] = true;
+  return wrappedHook;
+}
+function instrumentMongoose(mongoose, config) {
+  if (!mongoose?.Model) {
+    return mongoose;
+  }
+  const m = mongoose;
+  if (m[INSTRUMENTED_FLAG]) {
+    return mongoose;
+  }
+  const resolvedSerializer = config?.dbStatementSerializer;
+  const resolvedRedactor = config?.statementRedactor ?? "default";
+  const finalConfig = {
+    dbName: config?.dbName || "",
+    peerName: config?.peerName || "",
+    peerPort: config?.peerPort || 27017,
+    tracerName: config?.tracerName || DEFAULT_TRACER_NAME,
+    captureCollectionName: config?.captureCollectionName ?? true,
+    instrumentHooks: config?.instrumentHooks ?? false};
+  const tracer = otelTrace.getTracer(finalConfig.tracerName);
+  const captureStatement = createStatementCapture({
+    dbStatementSerializer: resolvedSerializer,
+    statementRedactor: resolvedRedactor
+  });
+  if (m.Schema && finalConfig.instrumentHooks) {
+    patchSchemaHooks(m.Schema, tracer, finalConfig);
+  }
+  const getModelCollectionName = (model) => {
+    try {
+      return model.collection?.collectionName || model.modelName;
+    } catch {
+      return;
+    }
+  };
+  const queryMethods = [
+    { method: "find", operation: "find" },
+    { method: "findOne", operation: "findOne" },
+    { method: "findById", operation: "findById" },
+    { method: "findOneAndUpdate", operation: "findOneAndUpdate" },
+    { method: "findOneAndDelete", operation: "findOneAndDelete" },
+    { method: "findOneAndReplace", operation: "findOneAndReplace" },
+    { method: "deleteOne", operation: "deleteOne" },
+    { method: "deleteMany", operation: "deleteMany" },
+    { method: "updateOne", operation: "updateOne" },
+    { method: "updateMany", operation: "updateMany" },
+    { method: "countDocuments", operation: "countDocuments" },
+    { method: "estimatedDocumentCount", operation: "estimatedDocumentCount" }
+  ];
+  for (const { method, operation } of queryMethods) {
+    wrapQueryReturningMethod(
+      m.Model,
+      method,
+      operation,
+      getModelCollectionName,
+      (model) => model.modelName,
+      tracer,
+      finalConfig,
+      captureStatement
+    );
+    if (m.Query?.prototype?.[method]) {
+      wrapChainableMethod(m.Query.prototype, method);
+    }
+  }
+  const instanceMethods = ["save", "deleteOne"];
+  for (const method of instanceMethods) {
+    if (m.Model.prototype[method]) {
+      wrapInstanceMethod(
+        m.Model.prototype,
+        method,
+        method,
+        (doc) => {
+          try {
+            return doc.constructor?.collection?.collectionName || doc.constructor?.modelName;
+          } catch {
+            return;
+          }
+        },
+        (doc) => {
+          try {
+            return doc.constructor?.modelName;
+          } catch {
+            return;
+          }
+        },
+        tracer,
+        finalConfig,
+        captureStatement
+      );
+    }
+  }
+  const staticMethods = ["create", "insertMany", "aggregate", "bulkWrite"];
+  for (const method of staticMethods) {
+    if (m.Model[method]) {
+      wrapStaticMethod(
+        m.Model,
+        method,
+        method,
+        (model) => {
+          try {
+            return model.collection?.collectionName;
+          } catch {
+            return;
+          }
+        },
+        (model) => model.modelName,
+        tracer,
+        finalConfig,
+        captureStatement
+      );
+    }
+  }
+  const chainableMethods = [
+    "populate",
+    "select",
+    "lean",
+    "where",
+    "sort",
+    "limit",
+    "skip"
+  ];
+  for (const method of chainableMethods) {
+    if (m.Query?.prototype?.[method]) {
+      wrapChainableMethod(m.Query.prototype, method);
+    }
+  }
+  m[INSTRUMENTED_FLAG] = true;
+  return mongoose;
+}
+
+export { instrumentMongoose };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map