@budibase/backend-core 2.13.45 → 2.13.47

package/dist/index.js

@@ -2905,6 +2905,124 @@ var init_newid = __esm({
   }
 });
 
+// src/db/instrumentation.ts
+var import_dd_trace, DDInstrumentedDatabase;
+var init_instrumentation = __esm({
+  "src/db/instrumentation.ts"() {
+    "use strict";
+    import_dd_trace = __toESM(require("dd-trace"));
+    DDInstrumentedDatabase = class {
+      constructor(db, resource) {
+        this.db = db;
+        this.resource = resource;
+      }
+      get name() {
+        return this.db.name;
+      }
+      exists() {
+        return import_dd_trace.default.trace("exists", { resource: this.resource }, (span) => {
+          span?.addTags({ db_name: this.name });
+          return this.db.exists();
+        });
+      }
+      checkSetup() {
+        return import_dd_trace.default.trace("checkSetup", { resource: this.resource }, (span) => {
+          span?.addTags({ db_name: this.name });
+          return this.db.checkSetup();
+        });
+      }
+      get(id) {
+        return import_dd_trace.default.trace("get", { resource: this.resource }, (span) => {
+          span?.addTags({ db_name: this.name, doc_id: id });
+          return this.db.get(id);
+        });
+      }
+      getMultiple(ids, opts) {
+        return import_dd_trace.default.trace("getMultiple", { resource: this.resource }, (span) => {
+          span?.addTags({
+            db_name: this.name,
+            num_docs: ids.length,
+            allow_missing: opts?.allowMissing
+          });
+          return this.db.getMultiple(ids, opts);
+        });
+      }
+      remove(id, rev) {
+        return import_dd_trace.default.trace("remove", { resource: this.resource }, (span) => {
+          span?.addTags({ db_name: this.name, doc_id: id });
+          return this.db.remove(id, rev);
+        });
+      }
+      put(document, opts) {
+        return import_dd_trace.default.trace("put", { resource: this.resource }, (span) => {
+          span?.addTags({ db_name: this.name, doc_id: document._id });
+          return this.db.put(document, opts);
+        });
+      }
+      bulkDocs(documents) {
+        return import_dd_trace.default.trace("bulkDocs", { resource: this.resource }, (span) => {
+          span?.addTags({ db_name: this.name, num_docs: documents.length });
+          return this.db.bulkDocs(documents);
+        });
+      }
+      allDocs(params2) {
+        return import_dd_trace.default.trace("allDocs", { resource: this.resource }, (span) => {
+          span?.addTags({ db_name: this.name });
+          return this.db.allDocs(params2);
+        });
+      }
+      query(viewName, params2) {
+        return import_dd_trace.default.trace("query", { resource: this.resource }, (span) => {
+          span?.addTags({ db_name: this.name, view_name: viewName });
+          return this.db.query(viewName, params2);
+        });
+      }
+      destroy() {
+        return import_dd_trace.default.trace("destroy", { resource: this.resource }, (span) => {
+          span?.addTags({ db_name: this.name });
+          return this.db.destroy();
+        });
+      }
+      compact() {
+        return import_dd_trace.default.trace("compact", { resource: this.resource }, (span) => {
+          span?.addTags({ db_name: this.name });
+          return this.db.compact();
+        });
+      }
+      dump(stream2, opts) {
+        return import_dd_trace.default.trace("dump", { resource: this.resource }, (span) => {
+          span?.addTags({ db_name: this.name });
+          return this.db.dump(stream2, opts);
+        });
+      }
+      load(...args) {
+        return import_dd_trace.default.trace("load", { resource: this.resource }, (span) => {
+          span?.addTags({ db_name: this.name });
+          return this.db.load(...args);
+        });
+      }
+      createIndex(...args) {
+        return import_dd_trace.default.trace("createIndex", { resource: this.resource }, (span) => {
+          span?.addTags({ db_name: this.name });
+          return this.db.createIndex(...args);
+        });
+      }
+      deleteIndex(...args) {
+        return import_dd_trace.default.trace("deleteIndex", { resource: this.resource }, (span) => {
+          span?.addTags({ db_name: this.name });
+          return this.db.deleteIndex(...args);
+        });
+      }
+      getIndexes(...args) {
+        return import_dd_trace.default.trace("getIndexes", { resource: this.resource }, (span) => {
+          span?.addTags({ db_name: this.name });
+          return this.db.getIndexes(...args);
+        });
+      }
+    };
+  }
+});
+
 // src/db/couch/DatabaseImpl.ts
 function buildNano(couchInfo) {
   return (0, import_nano.default)({
@@ -2918,10 +3036,8 @@ function buildNano(couchInfo) {
   });
 }
 function DatabaseWithConnection(dbName, connection, opts) {
-  if (!connection) {
-    throw new Error("Must provide connection details");
-  }
-  return new DatabaseImpl(dbName, opts, connection);
+  const db = new DatabaseImpl(dbName, opts, connection);
+  return new DDInstrumentedDatabase(db, "couchdb");
 }
 var import_nano, DatabaseImpl;
 var init_DatabaseImpl = __esm({
@@ -2933,6 +3049,7 @@ var init_DatabaseImpl = __esm({
     init_utils2();
     init_pouchDB();
     init_newid();
+    init_instrumentation();
     DatabaseImpl = class _DatabaseImpl {
       constructor(dbName, opts, connection) {
         this.couchInfo = getCouchInfo();
@@ -3149,7 +3266,7 @@ var init_couch = __esm({
 
 // src/db/db.ts
 function getDB(dbName, opts) {
-  return new DatabaseImpl(dbName, opts);
+  return new DDInstrumentedDatabase(new DatabaseImpl(dbName, opts), "couchdb");
 }
 async function doWithDB(dbName, cb, opts) {
   const db = getDB(dbName, opts);
@@ -3170,6 +3287,7 @@ var init_db3 = __esm({
   "src/db/db.ts"() {
     "use strict";
     init_couch();
+    init_instrumentation();
   }
 });
 
@@ -3406,6 +3524,13 @@ function isScim() {
   const scimCall = context?.isScim;
   return !!scimCall;
 }
+function getCurrentContext() {
+  try {
+    return Context.get();
+  } catch (e) {
+    return void 0;
+  }
+}
 var TEST_APP_ID, getProdAppId;
 var init_mainContext = __esm({
   "src/context/mainContext.ts"() {
@@ -3444,6 +3569,7 @@ __export(context_exports, {
   getAuditLogDBName: () => getAuditLogDBName,
   getAuditLogsDB: () => getAuditLogsDB,
   getAutomationId: () => getAutomationId,
+  getCurrentContext: () => getCurrentContext,
   getDevAppDB: () => getDevAppDB,
   getEnvironmentVariables: () => getEnvironmentVariables,
   getGlobalDB: () => getGlobalDB,
@@ -3604,17 +3730,52 @@ function cleanup() {
   }
   intervals = [];
 }
-var intervals;
+var intervals, ExecutionTimeoutError, ExecutionTimeTracker;
 var init_timers = __esm({
   "src/timers/timers.ts"() {
     "use strict";
     intervals = [];
+    ExecutionTimeoutError = class extends Error {
+      constructor() {
+        super(...arguments);
+        this.name = "ExecutionTimeoutError";
+      }
+    };
+    ExecutionTimeTracker = class _ExecutionTimeTracker {
+      constructor(limitMs) {
+        this.limitMs = limitMs;
+        this.totalTimeMs = 0;
+      }
+      static withLimit(limitMs) {
+        return new _ExecutionTimeTracker(limitMs);
+      }
+      track(f) {
+        this.checkLimit();
+        const start2 = process.hrtime.bigint();
+        try {
+          return f();
+        } finally {
+          const end2 = process.hrtime.bigint();
+          this.totalTimeMs += Number(end2 - start2) / 1e6;
+          this.checkLimit();
+        }
+      }
+      checkLimit() {
+        if (this.totalTimeMs > this.limitMs) {
+          throw new ExecutionTimeoutError(
+            `Execution time limit of ${this.limitMs}ms exceeded: ${this.totalTimeMs}ms`
+          );
+        }
+      }
+    };
   }
 });
 
 // src/timers/index.ts
 var timers_exports = {};
 __export(timers_exports, {
+  ExecutionTimeTracker: () => ExecutionTimeTracker,
+  ExecutionTimeoutError: () => ExecutionTimeoutError,
   cleanup: () => cleanup,
   clear: () => clear,
   set: () => set
@@ -6130,7 +6291,7 @@ var init_system2 = __esm({
 });
 
 // src/logging/pino/logger.ts
-var import_pino, import_pino_pretty, pinoInstance, isPlainObject2, isError2, isMessage2, getLogParams3, logger;
+var import_pino, import_pino_pretty, import_dd_trace2, import_ext, pinoInstance, isPlainObject2, isError2, isMessage2, getLogParams3, logger;
 var init_logger = __esm({
   "src/logging/pino/logger.ts"() {
     "use strict";
@@ -6139,6 +6300,8 @@ var init_logger = __esm({
     init_environment2();
     init_context2();
     init_correlation2();
+    import_dd_trace2 = __toESM(require("dd-trace"));
+    import_ext = require("dd-trace/ext");
     init_system2();
     if (!environment_default.DISABLE_PINO_LOGGER) {
       let isPlainObject = function(obj) {
@@ -6172,6 +6335,10 @@ var init_logger = __esm({
           identityType: identity?.type,
           correlationId: getId()
         };
+        const span = import_dd_trace2.default.scope().active();
+        if (span) {
+          import_dd_trace2.default.inject(span.context(), import_ext.formats.LOG, contextObject);
+        }
         const mergingObject = {
           err: error,
           pid: process.pid,
@@ -7070,6 +7237,9 @@ var Duration = class _Duration {
   static fromDays(duration) {
     return _Duration.from("days" /* DAYS */, duration);
   }
+  static fromMilliseconds(duration) {
+    return _Duration.from("milliseconds" /* MILLISECONDS */, duration);
+  }
 };
 
 // src/redis/redlockImpl.ts