@squiz/db-lib 1.68.0 → 1.70.0

package/lib/index.js

@@ -328,12 +328,12 @@ var require_InternalServerError = __commonJS({
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.InternalServerError = void 0;
     var ErrorWithHttpStatusCode_1 = require_ErrorWithHttpStatusCode();
-    var InternalServerError4 = class extends ErrorWithHttpStatusCode_1.ErrorWithHttpStatusCode {
+    var InternalServerError5 = class extends ErrorWithHttpStatusCode_1.ErrorWithHttpStatusCode {
       constructor(message) {
         super(500, message);
       }
     };
-    exports.InternalServerError = InternalServerError4;
+    exports.InternalServerError = InternalServerError5;
   }
 });
 
@@ -48883,8 +48883,8 @@ var require_exception_handler = __commonJS({
        * @returns {mixed} - TODO: add return description.
        */
       getTrace(err) {
-        const trace = err ? stackTrace.parse(err) : stackTrace.get();
-        return trace.map((site) => {
+        const trace2 = err ? stackTrace.parse(err) : stackTrace.get();
+        return trace2.map((site) => {
           return {
             column: site.getColumnNumber(),
             file: site.getFileName(),
@@ -49083,8 +49083,8 @@ var require_rejection_handler = __commonJS({
        * @returns {mixed} - TODO: add return description.
        */
       getTrace(err) {
-        const trace = err ? stackTrace.parse(err) : stackTrace.get();
-        return trace.map((site) => {
+        const trace2 = err ? stackTrace.parse(err) : stackTrace.get();
+        return trace2.map((site) => {
           return {
             column: site.getColumnNumber(),
             file: site.getFileName(),
@@ -49982,12 +49982,16 @@ var require_formatters = __commonJS({
       return winston_1.default.format.combine(winston_1.default.format.errors(), winston_1.default.format.json(), winston_1.default.format.timestamp({ alias: "time" }));
     }
     exports.getJsonFormat = getJsonFormat;
-    exports.errorFormatting = winston_1.default.format.printf((info) => {
+    var errorFormatting = (stringify3) => winston_1.default.format.printf((info) => {
+      if (stringify3 && typeof info.message === "object") {
+        info.message = JSON.stringify(info.message);
+      }
       const message = `${info.timestamp} ${info.level}: ${info.stack || info.message}`;
       return message;
     });
-    function getHumanFormat() {
-      return winston_1.default.format.combine(winston_1.default.format.colorize(), winston_1.default.format.timestamp(), winston_1.default.format.errors({ stack: true }), exports.errorFormatting);
+    exports.errorFormatting = errorFormatting;
+    function getHumanFormat(stringify3) {
+      return winston_1.default.format.combine(winston_1.default.format.colorize(), winston_1.default.format.timestamp(), winston_1.default.format.errors({ stack: true }), (0, exports.errorFormatting)(stringify3));
     }
     exports.getHumanFormat = getHumanFormat;
   }
@@ -50010,7 +50014,7 @@ var require_lib4 = __commonJS({
     } });
     function getLogger2(options) {
       var _a;
-      const formatter = options.format === "human" ? (0, formatters_1.getHumanFormat)() : (0, formatters_1.getJsonFormat)();
+      const formatter = options.format === "human" ? (0, formatters_1.getHumanFormat)(options.jsonStringify) : (0, formatters_1.getJsonFormat)();
       return winston_1.default.createLogger({
         defaultMeta: {
           ...options.meta,
@@ -51043,15 +51047,11 @@ var require_order = __commonJS({
       if (!map) {
         return sourceObject;
       }
-      const sortedMap = Object.keys(map).sort().reduce((obj, key) => {
-        obj[key] = map[key];
-        return obj;
-      }, {});
-      const mapKeys = Object.keys(sortedMap);
+      const mapKeys = Object.keys(map);
       const prefixLength = mapKeys[0] && mapKeys[0].length || 0;
       const resultObject = {};
       mapKeys.forEach((mk) => {
-        const childKeys = sortedMap[mk];
+        const childKeys = map[mk];
         const parentKey = mk.substr(prefixLength);
         const parent = getProperty(sourceObject, parentKey, separator);
         if (parent.exists) {
@@ -55662,6 +55662,1654 @@ var require_lib7 = __commonJS({
   }
 });
 
+// ../../node_modules/@opentelemetry/api/build/src/platform/node/globalThis.js
+var require_globalThis = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/platform/node/globalThis.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports._globalThis = void 0;
+    exports._globalThis = typeof globalThis === "object" ? globalThis : global;
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/platform/node/index.js
+var require_node3 = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/platform/node/index.js"(exports) {
+    "use strict";
+    var __createBinding6 = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      Object.defineProperty(o, k2, { enumerable: true, get: function() {
+        return m[k];
+      } });
+    } : function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      o[k2] = m[k];
+    });
+    var __exportStar6 = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m)
+        if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p))
+          __createBinding6(exports2, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    __exportStar6(require_globalThis(), exports);
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/platform/index.js
+var require_platform = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/platform/index.js"(exports) {
+    "use strict";
+    var __createBinding6 = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      Object.defineProperty(o, k2, { enumerable: true, get: function() {
+        return m[k];
+      } });
+    } : function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      o[k2] = m[k];
+    });
+    var __exportStar6 = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m)
+        if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p))
+          __createBinding6(exports2, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    __exportStar6(require_node3(), exports);
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/version.js
+var require_version = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/version.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.VERSION = void 0;
+    exports.VERSION = "1.6.0";
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/internal/semver.js
+var require_semver = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/internal/semver.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.isCompatible = exports._makeCompatibilityCheck = void 0;
+    var version_1 = require_version();
+    var re = /^(\d+)\.(\d+)\.(\d+)(-(.+))?$/;
+    function _makeCompatibilityCheck(ownVersion) {
+      const acceptedVersions = /* @__PURE__ */ new Set([ownVersion]);
+      const rejectedVersions = /* @__PURE__ */ new Set();
+      const myVersionMatch = ownVersion.match(re);
+      if (!myVersionMatch) {
+        return () => false;
+      }
+      const ownVersionParsed = {
+        major: +myVersionMatch[1],
+        minor: +myVersionMatch[2],
+        patch: +myVersionMatch[3],
+        prerelease: myVersionMatch[4]
+      };
+      if (ownVersionParsed.prerelease != null) {
+        return function isExactmatch(globalVersion) {
+          return globalVersion === ownVersion;
+        };
+      }
+      function _reject(v) {
+        rejectedVersions.add(v);
+        return false;
+      }
+      function _accept(v) {
+        acceptedVersions.add(v);
+        return true;
+      }
+      return function isCompatible(globalVersion) {
+        if (acceptedVersions.has(globalVersion)) {
+          return true;
+        }
+        if (rejectedVersions.has(globalVersion)) {
+          return false;
+        }
+        const globalVersionMatch = globalVersion.match(re);
+        if (!globalVersionMatch) {
+          return _reject(globalVersion);
+        }
+        const globalVersionParsed = {
+          major: +globalVersionMatch[1],
+          minor: +globalVersionMatch[2],
+          patch: +globalVersionMatch[3],
+          prerelease: globalVersionMatch[4]
+        };
+        if (globalVersionParsed.prerelease != null) {
+          return _reject(globalVersion);
+        }
+        if (ownVersionParsed.major !== globalVersionParsed.major) {
+          return _reject(globalVersion);
+        }
+        if (ownVersionParsed.major === 0) {
+          if (ownVersionParsed.minor === globalVersionParsed.minor && ownVersionParsed.patch <= globalVersionParsed.patch) {
+            return _accept(globalVersion);
+          }
+          return _reject(globalVersion);
+        }
+        if (ownVersionParsed.minor <= globalVersionParsed.minor) {
+          return _accept(globalVersion);
+        }
+        return _reject(globalVersion);
+      };
+    }
+    exports._makeCompatibilityCheck = _makeCompatibilityCheck;
+    exports.isCompatible = _makeCompatibilityCheck(version_1.VERSION);
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/internal/global-utils.js
+var require_global_utils = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/internal/global-utils.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.unregisterGlobal = exports.getGlobal = exports.registerGlobal = void 0;
+    var platform_1 = require_platform();
+    var version_1 = require_version();
+    var semver_1 = require_semver();
+    var major = version_1.VERSION.split(".")[0];
+    var GLOBAL_OPENTELEMETRY_API_KEY = Symbol.for(`opentelemetry.js.api.${major}`);
+    var _global = platform_1._globalThis;
+    function registerGlobal(type, instance, diag, allowOverride = false) {
+      var _a;
+      const api = _global[GLOBAL_OPENTELEMETRY_API_KEY] = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) !== null && _a !== void 0 ? _a : {
+        version: version_1.VERSION
+      };
+      if (!allowOverride && api[type]) {
+        const err = new Error(`@opentelemetry/api: Attempted duplicate registration of API: ${type}`);
+        diag.error(err.stack || err.message);
+        return false;
+      }
+      if (api.version !== version_1.VERSION) {
+        const err = new Error(`@opentelemetry/api: Registration of version v${api.version} for ${type} does not match previously registered API v${version_1.VERSION}`);
+        diag.error(err.stack || err.message);
+        return false;
+      }
+      api[type] = instance;
+      diag.debug(`@opentelemetry/api: Registered a global for ${type} v${version_1.VERSION}.`);
+      return true;
+    }
+    exports.registerGlobal = registerGlobal;
+    function getGlobal(type) {
+      var _a, _b;
+      const globalVersion = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _a === void 0 ? void 0 : _a.version;
+      if (!globalVersion || !(0, semver_1.isCompatible)(globalVersion)) {
+        return;
+      }
+      return (_b = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _b === void 0 ? void 0 : _b[type];
+    }
+    exports.getGlobal = getGlobal;
+    function unregisterGlobal(type, diag) {
+      diag.debug(`@opentelemetry/api: Unregistering a global for ${type} v${version_1.VERSION}.`);
+      const api = _global[GLOBAL_OPENTELEMETRY_API_KEY];
+      if (api) {
+        delete api[type];
+      }
+    }
+    exports.unregisterGlobal = unregisterGlobal;
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/diag/ComponentLogger.js
+var require_ComponentLogger = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/diag/ComponentLogger.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.DiagComponentLogger = void 0;
+    var global_utils_1 = require_global_utils();
+    var DiagComponentLogger = class {
+      constructor(props) {
+        this._namespace = props.namespace || "DiagComponentLogger";
+      }
+      debug(...args) {
+        return logProxy("debug", this._namespace, args);
+      }
+      error(...args) {
+        return logProxy("error", this._namespace, args);
+      }
+      info(...args) {
+        return logProxy("info", this._namespace, args);
+      }
+      warn(...args) {
+        return logProxy("warn", this._namespace, args);
+      }
+      verbose(...args) {
+        return logProxy("verbose", this._namespace, args);
+      }
+    };
+    exports.DiagComponentLogger = DiagComponentLogger;
+    function logProxy(funcName, namespace, args) {
+      const logger2 = (0, global_utils_1.getGlobal)("diag");
+      if (!logger2) {
+        return;
+      }
+      args.unshift(namespace);
+      return logger2[funcName](...args);
+    }
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/diag/types.js
+var require_types = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/diag/types.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.DiagLogLevel = void 0;
+    var DiagLogLevel;
+    (function(DiagLogLevel2) {
+      DiagLogLevel2[DiagLogLevel2["NONE"] = 0] = "NONE";
+      DiagLogLevel2[DiagLogLevel2["ERROR"] = 30] = "ERROR";
+      DiagLogLevel2[DiagLogLevel2["WARN"] = 50] = "WARN";
+      DiagLogLevel2[DiagLogLevel2["INFO"] = 60] = "INFO";
+      DiagLogLevel2[DiagLogLevel2["DEBUG"] = 70] = "DEBUG";
+      DiagLogLevel2[DiagLogLevel2["VERBOSE"] = 80] = "VERBOSE";
+      DiagLogLevel2[DiagLogLevel2["ALL"] = 9999] = "ALL";
+    })(DiagLogLevel = exports.DiagLogLevel || (exports.DiagLogLevel = {}));
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/diag/internal/logLevelLogger.js
+var require_logLevelLogger = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/diag/internal/logLevelLogger.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.createLogLevelDiagLogger = void 0;
+    var types_1 = require_types();
+    function createLogLevelDiagLogger(maxLevel, logger2) {
+      if (maxLevel < types_1.DiagLogLevel.NONE) {
+        maxLevel = types_1.DiagLogLevel.NONE;
+      } else if (maxLevel > types_1.DiagLogLevel.ALL) {
+        maxLevel = types_1.DiagLogLevel.ALL;
+      }
+      logger2 = logger2 || {};
+      function _filterFunc(funcName, theLevel) {
+        const theFunc = logger2[funcName];
+        if (typeof theFunc === "function" && maxLevel >= theLevel) {
+          return theFunc.bind(logger2);
+        }
+        return function() {
+        };
+      }
+      return {
+        error: _filterFunc("error", types_1.DiagLogLevel.ERROR),
+        warn: _filterFunc("warn", types_1.DiagLogLevel.WARN),
+        info: _filterFunc("info", types_1.DiagLogLevel.INFO),
+        debug: _filterFunc("debug", types_1.DiagLogLevel.DEBUG),
+        verbose: _filterFunc("verbose", types_1.DiagLogLevel.VERBOSE)
+      };
+    }
+    exports.createLogLevelDiagLogger = createLogLevelDiagLogger;
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/api/diag.js
+var require_diag = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/api/diag.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.DiagAPI = void 0;
+    var ComponentLogger_1 = require_ComponentLogger();
+    var logLevelLogger_1 = require_logLevelLogger();
+    var types_1 = require_types();
+    var global_utils_1 = require_global_utils();
+    var API_NAME = "diag";
+    var DiagAPI = class {
+      /**
+       * Private internal constructor
+       * @private
+       */
+      constructor() {
+        function _logProxy(funcName) {
+          return function(...args) {
+            const logger2 = (0, global_utils_1.getGlobal)("diag");
+            if (!logger2)
+              return;
+            return logger2[funcName](...args);
+          };
+        }
+        const self2 = this;
+        const setLogger = (logger2, optionsOrLogLevel = { logLevel: types_1.DiagLogLevel.INFO }) => {
+          var _a, _b, _c;
+          if (logger2 === self2) {
+            const err = new Error("Cannot use diag as the logger for itself. Please use a DiagLogger implementation like ConsoleDiagLogger or a custom implementation");
+            self2.error((_a = err.stack) !== null && _a !== void 0 ? _a : err.message);
+            return false;
+          }
+          if (typeof optionsOrLogLevel === "number") {
+            optionsOrLogLevel = {
+              logLevel: optionsOrLogLevel
+            };
+          }
+          const oldLogger = (0, global_utils_1.getGlobal)("diag");
+          const newLogger = (0, logLevelLogger_1.createLogLevelDiagLogger)((_b = optionsOrLogLevel.logLevel) !== null && _b !== void 0 ? _b : types_1.DiagLogLevel.INFO, logger2);
+          if (oldLogger && !optionsOrLogLevel.suppressOverrideMessage) {
+            const stack = (_c = new Error().stack) !== null && _c !== void 0 ? _c : "<failed to generate stacktrace>";
+            oldLogger.warn(`Current logger will be overwritten from ${stack}`);
+            newLogger.warn(`Current logger will overwrite one already registered from ${stack}`);
+          }
+          return (0, global_utils_1.registerGlobal)("diag", newLogger, self2, true);
+        };
+        self2.setLogger = setLogger;
+        self2.disable = () => {
+          (0, global_utils_1.unregisterGlobal)(API_NAME, self2);
+        };
+        self2.createComponentLogger = (options) => {
+          return new ComponentLogger_1.DiagComponentLogger(options);
+        };
+        self2.verbose = _logProxy("verbose");
+        self2.debug = _logProxy("debug");
+        self2.info = _logProxy("info");
+        self2.warn = _logProxy("warn");
+        self2.error = _logProxy("error");
+      }
+      /** Get the singleton instance of the DiagAPI API */
+      static instance() {
+        if (!this._instance) {
+          this._instance = new DiagAPI();
+        }
+        return this._instance;
+      }
+    };
+    exports.DiagAPI = DiagAPI;
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/baggage/internal/baggage-impl.js
+var require_baggage_impl = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/baggage/internal/baggage-impl.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.BaggageImpl = void 0;
+    var BaggageImpl = class {
+      constructor(entries) {
+        this._entries = entries ? new Map(entries) : /* @__PURE__ */ new Map();
+      }
+      getEntry(key) {
+        const entry = this._entries.get(key);
+        if (!entry) {
+          return void 0;
+        }
+        return Object.assign({}, entry);
+      }
+      getAllEntries() {
+        return Array.from(this._entries.entries()).map(([k, v]) => [k, v]);
+      }
+      setEntry(key, entry) {
+        const newBaggage = new BaggageImpl(this._entries);
+        newBaggage._entries.set(key, entry);
+        return newBaggage;
+      }
+      removeEntry(key) {
+        const newBaggage = new BaggageImpl(this._entries);
+        newBaggage._entries.delete(key);
+        return newBaggage;
+      }
+      removeEntries(...keys) {
+        const newBaggage = new BaggageImpl(this._entries);
+        for (const key of keys) {
+          newBaggage._entries.delete(key);
+        }
+        return newBaggage;
+      }
+      clear() {
+        return new BaggageImpl();
+      }
+    };
+    exports.BaggageImpl = BaggageImpl;
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/baggage/internal/symbol.js
+var require_symbol = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/baggage/internal/symbol.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.baggageEntryMetadataSymbol = void 0;
+    exports.baggageEntryMetadataSymbol = Symbol("BaggageEntryMetadata");
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/baggage/utils.js
+var require_utils4 = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/baggage/utils.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.baggageEntryMetadataFromString = exports.createBaggage = void 0;
+    var diag_1 = require_diag();
+    var baggage_impl_1 = require_baggage_impl();
+    var symbol_1 = require_symbol();
+    var diag = diag_1.DiagAPI.instance();
+    function createBaggage(entries = {}) {
+      return new baggage_impl_1.BaggageImpl(new Map(Object.entries(entries)));
+    }
+    exports.createBaggage = createBaggage;
+    function baggageEntryMetadataFromString(str) {
+      if (typeof str !== "string") {
+        diag.error(`Cannot create baggage metadata from unknown type: ${typeof str}`);
+        str = "";
+      }
+      return {
+        __TYPE__: symbol_1.baggageEntryMetadataSymbol,
+        toString() {
+          return str;
+        }
+      };
+    }
+    exports.baggageEntryMetadataFromString = baggageEntryMetadataFromString;
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/context/context.js
+var require_context = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/context/context.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ROOT_CONTEXT = exports.createContextKey = void 0;
+    function createContextKey(description) {
+      return Symbol.for(description);
+    }
+    exports.createContextKey = createContextKey;
+    var BaseContext = class {
+      /**
+       * Construct a new context which inherits values from an optional parent context.
+       *
+       * @param parentContext a context from which to inherit values
+       */
+      constructor(parentContext) {
+        const self2 = this;
+        self2._currentContext = parentContext ? new Map(parentContext) : /* @__PURE__ */ new Map();
+        self2.getValue = (key) => self2._currentContext.get(key);
+        self2.setValue = (key, value) => {
+          const context = new BaseContext(self2._currentContext);
+          context._currentContext.set(key, value);
+          return context;
+        };
+        self2.deleteValue = (key) => {
+          const context = new BaseContext(self2._currentContext);
+          context._currentContext.delete(key);
+          return context;
+        };
+      }
+    };
+    exports.ROOT_CONTEXT = new BaseContext();
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/diag/consoleLogger.js
+var require_consoleLogger = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/diag/consoleLogger.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.DiagConsoleLogger = void 0;
+    var consoleMap = [
+      { n: "error", c: "error" },
+      { n: "warn", c: "warn" },
+      { n: "info", c: "info" },
+      { n: "debug", c: "debug" },
+      { n: "verbose", c: "trace" }
+    ];
+    var DiagConsoleLogger = class {
+      constructor() {
+        function _consoleFunc(funcName) {
+          return function(...args) {
+            if (console) {
+              let theFunc = console[funcName];
+              if (typeof theFunc !== "function") {
+                theFunc = console.log;
+              }
+              if (typeof theFunc === "function") {
+                return theFunc.apply(console, args);
+              }
+            }
+          };
+        }
+        for (let i = 0; i < consoleMap.length; i++) {
+          this[consoleMap[i].n] = _consoleFunc(consoleMap[i].c);
+        }
+      }
+    };
+    exports.DiagConsoleLogger = DiagConsoleLogger;
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/metrics/NoopMeter.js
+var require_NoopMeter = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/metrics/NoopMeter.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.createNoopMeter = exports.NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC = exports.NOOP_OBSERVABLE_GAUGE_METRIC = exports.NOOP_OBSERVABLE_COUNTER_METRIC = exports.NOOP_UP_DOWN_COUNTER_METRIC = exports.NOOP_HISTOGRAM_METRIC = exports.NOOP_COUNTER_METRIC = exports.NOOP_METER = exports.NoopObservableUpDownCounterMetric = exports.NoopObservableGaugeMetric = exports.NoopObservableCounterMetric = exports.NoopObservableMetric = exports.NoopHistogramMetric = exports.NoopUpDownCounterMetric = exports.NoopCounterMetric = exports.NoopMetric = exports.NoopMeter = void 0;
+    var NoopMeter = class {
+      constructor() {
+      }
+      /**
+       * @see {@link Meter.createHistogram}
+       */
+      createHistogram(_name, _options) {
+        return exports.NOOP_HISTOGRAM_METRIC;
+      }
+      /**
+       * @see {@link Meter.createCounter}
+       */
+      createCounter(_name, _options) {
+        return exports.NOOP_COUNTER_METRIC;
+      }
+      /**
+       * @see {@link Meter.createUpDownCounter}
+       */
+      createUpDownCounter(_name, _options) {
+        return exports.NOOP_UP_DOWN_COUNTER_METRIC;
+      }
+      /**
+       * @see {@link Meter.createObservableGauge}
+       */
+      createObservableGauge(_name, _options) {
+        return exports.NOOP_OBSERVABLE_GAUGE_METRIC;
+      }
+      /**
+       * @see {@link Meter.createObservableCounter}
+       */
+      createObservableCounter(_name, _options) {
+        return exports.NOOP_OBSERVABLE_COUNTER_METRIC;
+      }
+      /**
+       * @see {@link Meter.createObservableUpDownCounter}
+       */
+      createObservableUpDownCounter(_name, _options) {
+        return exports.NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC;
+      }
+      /**
+       * @see {@link Meter.addBatchObservableCallback}
+       */
+      addBatchObservableCallback(_callback, _observables) {
+      }
+      /**
+       * @see {@link Meter.removeBatchObservableCallback}
+       */
+      removeBatchObservableCallback(_callback) {
+      }
+    };
+    exports.NoopMeter = NoopMeter;
+    var NoopMetric = class {
+    };
+    exports.NoopMetric = NoopMetric;
+    var NoopCounterMetric = class extends NoopMetric {
+      add(_value, _attributes) {
+      }
+    };
+    exports.NoopCounterMetric = NoopCounterMetric;
+    var NoopUpDownCounterMetric = class extends NoopMetric {
+      add(_value, _attributes) {
+      }
+    };
+    exports.NoopUpDownCounterMetric = NoopUpDownCounterMetric;
+    var NoopHistogramMetric = class extends NoopMetric {
+      record(_value, _attributes) {
+      }
+    };
+    exports.NoopHistogramMetric = NoopHistogramMetric;
+    var NoopObservableMetric = class {
+      addCallback(_callback) {
+      }
+      removeCallback(_callback) {
+      }
+    };
+    exports.NoopObservableMetric = NoopObservableMetric;
+    var NoopObservableCounterMetric = class extends NoopObservableMetric {
+    };
+    exports.NoopObservableCounterMetric = NoopObservableCounterMetric;
+    var NoopObservableGaugeMetric = class extends NoopObservableMetric {
+    };
+    exports.NoopObservableGaugeMetric = NoopObservableGaugeMetric;
+    var NoopObservableUpDownCounterMetric = class extends NoopObservableMetric {
+    };
+    exports.NoopObservableUpDownCounterMetric = NoopObservableUpDownCounterMetric;
+    exports.NOOP_METER = new NoopMeter();
+    exports.NOOP_COUNTER_METRIC = new NoopCounterMetric();
+    exports.NOOP_HISTOGRAM_METRIC = new NoopHistogramMetric();
+    exports.NOOP_UP_DOWN_COUNTER_METRIC = new NoopUpDownCounterMetric();
+    exports.NOOP_OBSERVABLE_COUNTER_METRIC = new NoopObservableCounterMetric();
+    exports.NOOP_OBSERVABLE_GAUGE_METRIC = new NoopObservableGaugeMetric();
+    exports.NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC = new NoopObservableUpDownCounterMetric();
+    function createNoopMeter() {
+      return exports.NOOP_METER;
+    }
+    exports.createNoopMeter = createNoopMeter;
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/metrics/Metric.js
+var require_Metric = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/metrics/Metric.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ValueType = void 0;
+    var ValueType;
+    (function(ValueType2) {
+      ValueType2[ValueType2["INT"] = 0] = "INT";
+      ValueType2[ValueType2["DOUBLE"] = 1] = "DOUBLE";
+    })(ValueType = exports.ValueType || (exports.ValueType = {}));
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/propagation/TextMapPropagator.js
+var require_TextMapPropagator = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/propagation/TextMapPropagator.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.defaultTextMapSetter = exports.defaultTextMapGetter = void 0;
+    exports.defaultTextMapGetter = {
+      get(carrier, key) {
+        if (carrier == null) {
+          return void 0;
+        }
+        return carrier[key];
+      },
+      keys(carrier) {
+        if (carrier == null) {
+          return [];
+        }
+        return Object.keys(carrier);
+      }
+    };
+    exports.defaultTextMapSetter = {
+      set(carrier, key, value) {
+        if (carrier == null) {
+          return;
+        }
+        carrier[key] = value;
+      }
+    };
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/context/NoopContextManager.js
+var require_NoopContextManager = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/context/NoopContextManager.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.NoopContextManager = void 0;
+    var context_1 = require_context();
+    var NoopContextManager = class {
+      active() {
+        return context_1.ROOT_CONTEXT;
+      }
+      with(_context, fn, thisArg, ...args) {
+        return fn.call(thisArg, ...args);
+      }
+      bind(_context, target) {
+        return target;
+      }
+      enable() {
+        return this;
+      }
+      disable() {
+        return this;
+      }
+    };
+    exports.NoopContextManager = NoopContextManager;
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/api/context.js
+var require_context2 = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/api/context.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ContextAPI = void 0;
+    var NoopContextManager_1 = require_NoopContextManager();
+    var global_utils_1 = require_global_utils();
+    var diag_1 = require_diag();
+    var API_NAME = "context";
+    var NOOP_CONTEXT_MANAGER = new NoopContextManager_1.NoopContextManager();
+    var ContextAPI = class {
+      /** Empty private constructor prevents end users from constructing a new instance of the API */
+      constructor() {
+      }
+      /** Get the singleton instance of the Context API */
+      static getInstance() {
+        if (!this._instance) {
+          this._instance = new ContextAPI();
+        }
+        return this._instance;
+      }
+      /**
+       * Set the current context manager.
+       *
+       * @returns true if the context manager was successfully registered, else false
+       */
+      setGlobalContextManager(contextManager) {
+        return (0, global_utils_1.registerGlobal)(API_NAME, contextManager, diag_1.DiagAPI.instance());
+      }
+      /**
+       * Get the currently active context
+       */
+      active() {
+        return this._getContextManager().active();
+      }
+      /**
+       * Execute a function with an active context
+       *
+       * @param context context to be active during function execution
+       * @param fn function to execute in a context
+       * @param thisArg optional receiver to be used for calling fn
+       * @param args optional arguments forwarded to fn
+       */
+      with(context, fn, thisArg, ...args) {
+        return this._getContextManager().with(context, fn, thisArg, ...args);
+      }
+      /**
+       * Bind a context to a target function or event emitter
+       *
+       * @param context context to bind to the event emitter or function. Defaults to the currently active context
+       * @param target function or event emitter to bind
+       */
+      bind(context, target) {
+        return this._getContextManager().bind(context, target);
+      }
+      _getContextManager() {
+        return (0, global_utils_1.getGlobal)(API_NAME) || NOOP_CONTEXT_MANAGER;
+      }
+      /** Disable and remove the global context manager */
+      disable() {
+        this._getContextManager().disable();
+        (0, global_utils_1.unregisterGlobal)(API_NAME, diag_1.DiagAPI.instance());
+      }
+    };
+    exports.ContextAPI = ContextAPI;
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/trace/trace_flags.js
+var require_trace_flags = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/trace/trace_flags.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.TraceFlags = void 0;
+    var TraceFlags;
+    (function(TraceFlags2) {
+      TraceFlags2[TraceFlags2["NONE"] = 0] = "NONE";
+      TraceFlags2[TraceFlags2["SAMPLED"] = 1] = "SAMPLED";
+    })(TraceFlags = exports.TraceFlags || (exports.TraceFlags = {}));
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/trace/invalid-span-constants.js
+var require_invalid_span_constants = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/trace/invalid-span-constants.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.INVALID_SPAN_CONTEXT = exports.INVALID_TRACEID = exports.INVALID_SPANID = void 0;
+    var trace_flags_1 = require_trace_flags();
+    exports.INVALID_SPANID = "0000000000000000";
+    exports.INVALID_TRACEID = "00000000000000000000000000000000";
+    exports.INVALID_SPAN_CONTEXT = {
+      traceId: exports.INVALID_TRACEID,
+      spanId: exports.INVALID_SPANID,
+      traceFlags: trace_flags_1.TraceFlags.NONE
+    };
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/trace/NonRecordingSpan.js
+var require_NonRecordingSpan = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/trace/NonRecordingSpan.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.NonRecordingSpan = void 0;
+    var invalid_span_constants_1 = require_invalid_span_constants();
+    var NonRecordingSpan = class {
+      constructor(_spanContext = invalid_span_constants_1.INVALID_SPAN_CONTEXT) {
+        this._spanContext = _spanContext;
+      }
+      // Returns a SpanContext.
+      spanContext() {
+        return this._spanContext;
+      }
+      // By default does nothing
+      setAttribute(_key, _value) {
+        return this;
+      }
+      // By default does nothing
+      setAttributes(_attributes) {
+        return this;
+      }
+      // By default does nothing
+      addEvent(_name, _attributes) {
+        return this;
+      }
+      // By default does nothing
+      setStatus(_status) {
+        return this;
+      }
+      // By default does nothing
+      updateName(_name) {
+        return this;
+      }
+      // By default does nothing
+      end(_endTime) {
+      }
+      // isRecording always returns false for NonRecordingSpan.
+      isRecording() {
+        return false;
+      }
+      // By default does nothing
+      recordException(_exception, _time) {
+      }
+    };
+    exports.NonRecordingSpan = NonRecordingSpan;
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/trace/context-utils.js
+var require_context_utils = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/trace/context-utils.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.getSpanContext = exports.setSpanContext = exports.deleteSpan = exports.setSpan = exports.getActiveSpan = exports.getSpan = void 0;
+    var context_1 = require_context();
+    var NonRecordingSpan_1 = require_NonRecordingSpan();
+    var context_2 = require_context2();
+    var SPAN_KEY = (0, context_1.createContextKey)("OpenTelemetry Context Key SPAN");
+    function getSpan(context) {
+      return context.getValue(SPAN_KEY) || void 0;
+    }
+    exports.getSpan = getSpan;
+    function getActiveSpan() {
+      return getSpan(context_2.ContextAPI.getInstance().active());
+    }
+    exports.getActiveSpan = getActiveSpan;
+    function setSpan(context, span) {
+      return context.setValue(SPAN_KEY, span);
+    }
+    exports.setSpan = setSpan;
+    function deleteSpan(context) {
+      return context.deleteValue(SPAN_KEY);
+    }
+    exports.deleteSpan = deleteSpan;
+    function setSpanContext(context, spanContext) {
+      return setSpan(context, new NonRecordingSpan_1.NonRecordingSpan(spanContext));
+    }
+    exports.setSpanContext = setSpanContext;
+    function getSpanContext(context) {
+      var _a;
+      return (_a = getSpan(context)) === null || _a === void 0 ? void 0 : _a.spanContext();
+    }
+    exports.getSpanContext = getSpanContext;
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/trace/spancontext-utils.js
+var require_spancontext_utils = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/trace/spancontext-utils.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.wrapSpanContext = exports.isSpanContextValid = exports.isValidSpanId = exports.isValidTraceId = void 0;
+    var invalid_span_constants_1 = require_invalid_span_constants();
+    var NonRecordingSpan_1 = require_NonRecordingSpan();
+    var VALID_TRACEID_REGEX = /^([0-9a-f]{32})$/i;
+    var VALID_SPANID_REGEX = /^[0-9a-f]{16}$/i;
+    function isValidTraceId(traceId) {
+      return VALID_TRACEID_REGEX.test(traceId) && traceId !== invalid_span_constants_1.INVALID_TRACEID;
+    }
+    exports.isValidTraceId = isValidTraceId;
+    function isValidSpanId(spanId) {
+      return VALID_SPANID_REGEX.test(spanId) && spanId !== invalid_span_constants_1.INVALID_SPANID;
+    }
+    exports.isValidSpanId = isValidSpanId;
+    function isSpanContextValid(spanContext) {
+      return isValidTraceId(spanContext.traceId) && isValidSpanId(spanContext.spanId);
+    }
+    exports.isSpanContextValid = isSpanContextValid;
+    function wrapSpanContext(spanContext) {
+      return new NonRecordingSpan_1.NonRecordingSpan(spanContext);
+    }
+    exports.wrapSpanContext = wrapSpanContext;
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/trace/NoopTracer.js
+var require_NoopTracer = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/trace/NoopTracer.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.NoopTracer = void 0;
+    var context_1 = require_context2();
+    var context_utils_1 = require_context_utils();
+    var NonRecordingSpan_1 = require_NonRecordingSpan();
+    var spancontext_utils_1 = require_spancontext_utils();
+    var contextApi = context_1.ContextAPI.getInstance();
+    var NoopTracer = class {
+      // startSpan starts a noop span.
+      startSpan(name, options, context = contextApi.active()) {
+        const root = Boolean(options === null || options === void 0 ? void 0 : options.root);
+        if (root) {
+          return new NonRecordingSpan_1.NonRecordingSpan();
+        }
+        const parentFromContext = context && (0, context_utils_1.getSpanContext)(context);
+        if (isSpanContext(parentFromContext) && (0, spancontext_utils_1.isSpanContextValid)(parentFromContext)) {
+          return new NonRecordingSpan_1.NonRecordingSpan(parentFromContext);
+        } else {
+          return new NonRecordingSpan_1.NonRecordingSpan();
+        }
+      }
+      startActiveSpan(name, arg2, arg3, arg4) {
+        let opts;
+        let ctx;
+        let fn;
+        if (arguments.length < 2) {
+          return;
+        } else if (arguments.length === 2) {
+          fn = arg2;
+        } else if (arguments.length === 3) {
+          opts = arg2;
+          fn = arg3;
+        } else {
+          opts = arg2;
+          ctx = arg3;
+          fn = arg4;
+        }
+        const parentContext = ctx !== null && ctx !== void 0 ? ctx : contextApi.active();
+        const span = this.startSpan(name, opts, parentContext);
+        const contextWithSpanSet = (0, context_utils_1.setSpan)(parentContext, span);
+        return contextApi.with(contextWithSpanSet, fn, void 0, span);
+      }
+    };
+    exports.NoopTracer = NoopTracer;
+    function isSpanContext(spanContext) {
+      return typeof spanContext === "object" && typeof spanContext["spanId"] === "string" && typeof spanContext["traceId"] === "string" && typeof spanContext["traceFlags"] === "number";
+    }
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/trace/ProxyTracer.js
+var require_ProxyTracer = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/trace/ProxyTracer.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ProxyTracer = void 0;
+    var NoopTracer_1 = require_NoopTracer();
+    var NOOP_TRACER = new NoopTracer_1.NoopTracer();
+    var ProxyTracer = class {
+      constructor(_provider, name, version3, options) {
+        this._provider = _provider;
+        this.name = name;
+        this.version = version3;
+        this.options = options;
+      }
+      startSpan(name, options, context) {
+        return this._getTracer().startSpan(name, options, context);
+      }
+      startActiveSpan(_name, _options, _context, _fn) {
+        const tracer2 = this._getTracer();
+        return Reflect.apply(tracer2.startActiveSpan, tracer2, arguments);
+      }
+      /**
+       * Try to get a tracer from the proxy tracer provider.
+       * If the proxy tracer provider has no delegate, return a noop tracer.
+       */
+      _getTracer() {
+        if (this._delegate) {
+          return this._delegate;
+        }
+        const tracer2 = this._provider.getDelegateTracer(this.name, this.version, this.options);
+        if (!tracer2) {
+          return NOOP_TRACER;
+        }
+        this._delegate = tracer2;
+        return this._delegate;
+      }
+    };
+    exports.ProxyTracer = ProxyTracer;
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/trace/NoopTracerProvider.js
+var require_NoopTracerProvider = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/trace/NoopTracerProvider.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.NoopTracerProvider = void 0;
+    var NoopTracer_1 = require_NoopTracer();
+    var NoopTracerProvider = class {
+      getTracer(_name, _version, _options) {
+        return new NoopTracer_1.NoopTracer();
+      }
+    };
+    exports.NoopTracerProvider = NoopTracerProvider;
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/trace/ProxyTracerProvider.js
+var require_ProxyTracerProvider = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/trace/ProxyTracerProvider.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ProxyTracerProvider = void 0;
+    var ProxyTracer_1 = require_ProxyTracer();
+    var NoopTracerProvider_1 = require_NoopTracerProvider();
+    var NOOP_TRACER_PROVIDER = new NoopTracerProvider_1.NoopTracerProvider();
+    var ProxyTracerProvider = class {
+      /**
+       * Get a {@link ProxyTracer}
+       */
+      getTracer(name, version3, options) {
+        var _a;
+        return (_a = this.getDelegateTracer(name, version3, options)) !== null && _a !== void 0 ? _a : new ProxyTracer_1.ProxyTracer(this, name, version3, options);
+      }
+      getDelegate() {
+        var _a;
+        return (_a = this._delegate) !== null && _a !== void 0 ? _a : NOOP_TRACER_PROVIDER;
+      }
+      /**
+       * Set the delegate tracer provider
+       */
+      setDelegate(delegate) {
+        this._delegate = delegate;
+      }
+      getDelegateTracer(name, version3, options) {
+        var _a;
+        return (_a = this._delegate) === null || _a === void 0 ? void 0 : _a.getTracer(name, version3, options);
+      }
+    };
+    exports.ProxyTracerProvider = ProxyTracerProvider;
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/trace/SamplingResult.js
+var require_SamplingResult = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/trace/SamplingResult.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.SamplingDecision = void 0;
+    var SamplingDecision;
+    (function(SamplingDecision2) {
+      SamplingDecision2[SamplingDecision2["NOT_RECORD"] = 0] = "NOT_RECORD";
+      SamplingDecision2[SamplingDecision2["RECORD"] = 1] = "RECORD";
+      SamplingDecision2[SamplingDecision2["RECORD_AND_SAMPLED"] = 2] = "RECORD_AND_SAMPLED";
+    })(SamplingDecision = exports.SamplingDecision || (exports.SamplingDecision = {}));
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/trace/span_kind.js
+var require_span_kind = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/trace/span_kind.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.SpanKind = void 0;
+    var SpanKind;
+    (function(SpanKind2) {
+      SpanKind2[SpanKind2["INTERNAL"] = 0] = "INTERNAL";
+      SpanKind2[SpanKind2["SERVER"] = 1] = "SERVER";
+      SpanKind2[SpanKind2["CLIENT"] = 2] = "CLIENT";
+      SpanKind2[SpanKind2["PRODUCER"] = 3] = "PRODUCER";
+      SpanKind2[SpanKind2["CONSUMER"] = 4] = "CONSUMER";
+    })(SpanKind = exports.SpanKind || (exports.SpanKind = {}));
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/trace/status.js
+var require_status = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/trace/status.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.SpanStatusCode = void 0;
+    var SpanStatusCode;
+    (function(SpanStatusCode2) {
+      SpanStatusCode2[SpanStatusCode2["UNSET"] = 0] = "UNSET";
+      SpanStatusCode2[SpanStatusCode2["OK"] = 1] = "OK";
+      SpanStatusCode2[SpanStatusCode2["ERROR"] = 2] = "ERROR";
+    })(SpanStatusCode = exports.SpanStatusCode || (exports.SpanStatusCode = {}));
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/trace/internal/tracestate-validators.js
+var require_tracestate_validators = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/trace/internal/tracestate-validators.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.validateValue = exports.validateKey = void 0;
+    var VALID_KEY_CHAR_RANGE = "[_0-9a-z-*/]";
+    var VALID_KEY = `[a-z]${VALID_KEY_CHAR_RANGE}{0,255}`;
+    var VALID_VENDOR_KEY = `[a-z0-9]${VALID_KEY_CHAR_RANGE}{0,240}@[a-z]${VALID_KEY_CHAR_RANGE}{0,13}`;
+    var VALID_KEY_REGEX = new RegExp(`^(?:${VALID_KEY}|${VALID_VENDOR_KEY})$`);
+    var VALID_VALUE_BASE_REGEX = /^[ -~]{0,255}[!-~]$/;
+    var INVALID_VALUE_COMMA_EQUAL_REGEX = /,|=/;
+    function validateKey(key) {
+      return VALID_KEY_REGEX.test(key);
+    }
+    exports.validateKey = validateKey;
+    function validateValue(value) {
+      return VALID_VALUE_BASE_REGEX.test(value) && !INVALID_VALUE_COMMA_EQUAL_REGEX.test(value);
+    }
+    exports.validateValue = validateValue;
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/trace/internal/tracestate-impl.js
+var require_tracestate_impl = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/trace/internal/tracestate-impl.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.TraceStateImpl = void 0;
+    var tracestate_validators_1 = require_tracestate_validators();
+    var MAX_TRACE_STATE_ITEMS = 32;
+    var MAX_TRACE_STATE_LEN = 512;
+    var LIST_MEMBERS_SEPARATOR = ",";
+    var LIST_MEMBER_KEY_VALUE_SPLITTER = "=";
+    var TraceStateImpl = class {
+      constructor(rawTraceState) {
+        this._internalState = /* @__PURE__ */ new Map();
+        if (rawTraceState)
+          this._parse(rawTraceState);
+      }
+      set(key, value) {
+        const traceState = this._clone();
+        if (traceState._internalState.has(key)) {
+          traceState._internalState.delete(key);
+        }
+        traceState._internalState.set(key, value);
+        return traceState;
+      }
+      unset(key) {
+        const traceState = this._clone();
+        traceState._internalState.delete(key);
+        return traceState;
+      }
+      get(key) {
+        return this._internalState.get(key);
+      }
+      serialize() {
+        return this._keys().reduce((agg, key) => {
+          agg.push(key + LIST_MEMBER_KEY_VALUE_SPLITTER + this.get(key));
+          return agg;
+        }, []).join(LIST_MEMBERS_SEPARATOR);
+      }
+      _parse(rawTraceState) {
+        if (rawTraceState.length > MAX_TRACE_STATE_LEN)
+          return;
+        this._internalState = rawTraceState.split(LIST_MEMBERS_SEPARATOR).reverse().reduce((agg, part) => {
+          const listMember = part.trim();
+          const i = listMember.indexOf(LIST_MEMBER_KEY_VALUE_SPLITTER);
+          if (i !== -1) {
+            const key = listMember.slice(0, i);
+            const value = listMember.slice(i + 1, part.length);
+            if ((0, tracestate_validators_1.validateKey)(key) && (0, tracestate_validators_1.validateValue)(value)) {
+              agg.set(key, value);
+            } else {
+            }
+          }
+          return agg;
+        }, /* @__PURE__ */ new Map());
+        if (this._internalState.size > MAX_TRACE_STATE_ITEMS) {
+          this._internalState = new Map(Array.from(this._internalState.entries()).reverse().slice(0, MAX_TRACE_STATE_ITEMS));
+        }
+      }
+      _keys() {
+        return Array.from(this._internalState.keys()).reverse();
+      }
+      _clone() {
+        const traceState = new TraceStateImpl();
+        traceState._internalState = new Map(this._internalState);
+        return traceState;
+      }
+    };
+    exports.TraceStateImpl = TraceStateImpl;
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/trace/internal/utils.js
+var require_utils5 = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/trace/internal/utils.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.createTraceState = void 0;
+    var tracestate_impl_1 = require_tracestate_impl();
+    function createTraceState(rawTraceState) {
+      return new tracestate_impl_1.TraceStateImpl(rawTraceState);
+    }
+    exports.createTraceState = createTraceState;
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/context-api.js
+var require_context_api = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/context-api.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.context = void 0;
+    var context_1 = require_context2();
+    exports.context = context_1.ContextAPI.getInstance();
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/diag-api.js
+var require_diag_api = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/diag-api.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.diag = void 0;
+    var diag_1 = require_diag();
+    exports.diag = diag_1.DiagAPI.instance();
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/metrics/NoopMeterProvider.js
+var require_NoopMeterProvider = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/metrics/NoopMeterProvider.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.NOOP_METER_PROVIDER = exports.NoopMeterProvider = void 0;
+    var NoopMeter_1 = require_NoopMeter();
+    var NoopMeterProvider = class {
+      getMeter(_name, _version, _options) {
+        return NoopMeter_1.NOOP_METER;
+      }
+    };
+    exports.NoopMeterProvider = NoopMeterProvider;
+    exports.NOOP_METER_PROVIDER = new NoopMeterProvider();
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/api/metrics.js
+var require_metrics = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/api/metrics.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.MetricsAPI = void 0;
+    var NoopMeterProvider_1 = require_NoopMeterProvider();
+    var global_utils_1 = require_global_utils();
+    var diag_1 = require_diag();
+    var API_NAME = "metrics";
+    var MetricsAPI = class {
+      /** Empty private constructor prevents end users from constructing a new instance of the API */
+      constructor() {
+      }
+      /** Get the singleton instance of the Metrics API */
+      static getInstance() {
+        if (!this._instance) {
+          this._instance = new MetricsAPI();
+        }
+        return this._instance;
+      }
+      /**
+       * Set the current global meter provider.
+       * Returns true if the meter provider was successfully registered, else false.
+       */
+      setGlobalMeterProvider(provider) {
+        return (0, global_utils_1.registerGlobal)(API_NAME, provider, diag_1.DiagAPI.instance());
+      }
+      /**
+       * Returns the global meter provider.
+       */
+      getMeterProvider() {
+        return (0, global_utils_1.getGlobal)(API_NAME) || NoopMeterProvider_1.NOOP_METER_PROVIDER;
+      }
+      /**
+       * Returns a meter from the global meter provider.
+       */
+      getMeter(name, version3, options) {
+        return this.getMeterProvider().getMeter(name, version3, options);
+      }
+      /** Remove the global meter provider */
+      disable() {
+        (0, global_utils_1.unregisterGlobal)(API_NAME, diag_1.DiagAPI.instance());
+      }
+    };
+    exports.MetricsAPI = MetricsAPI;
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/metrics-api.js
+var require_metrics_api = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/metrics-api.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.metrics = void 0;
+    var metrics_1 = require_metrics();
+    exports.metrics = metrics_1.MetricsAPI.getInstance();
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/propagation/NoopTextMapPropagator.js
+var require_NoopTextMapPropagator = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/propagation/NoopTextMapPropagator.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.NoopTextMapPropagator = void 0;
+    var NoopTextMapPropagator = class {
+      /** Noop inject function does nothing */
+      inject(_context, _carrier) {
+      }
+      /** Noop extract function does nothing and returns the input context */
+      extract(context, _carrier) {
+        return context;
+      }
+      fields() {
+        return [];
+      }
+    };
+    exports.NoopTextMapPropagator = NoopTextMapPropagator;
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/baggage/context-helpers.js
+var require_context_helpers = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/baggage/context-helpers.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.deleteBaggage = exports.setBaggage = exports.getActiveBaggage = exports.getBaggage = void 0;
+    var context_1 = require_context2();
+    var context_2 = require_context();
+    var BAGGAGE_KEY = (0, context_2.createContextKey)("OpenTelemetry Baggage Key");
+    function getBaggage(context) {
+      return context.getValue(BAGGAGE_KEY) || void 0;
+    }
+    exports.getBaggage = getBaggage;
+    function getActiveBaggage() {
+      return getBaggage(context_1.ContextAPI.getInstance().active());
+    }
+    exports.getActiveBaggage = getActiveBaggage;
+    function setBaggage(context, baggage) {
+      return context.setValue(BAGGAGE_KEY, baggage);
+    }
+    exports.setBaggage = setBaggage;
+    function deleteBaggage(context) {
+      return context.deleteValue(BAGGAGE_KEY);
+    }
+    exports.deleteBaggage = deleteBaggage;
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/api/propagation.js
+var require_propagation = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/api/propagation.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.PropagationAPI = void 0;
+    var global_utils_1 = require_global_utils();
+    var NoopTextMapPropagator_1 = require_NoopTextMapPropagator();
+    var TextMapPropagator_1 = require_TextMapPropagator();
+    var context_helpers_1 = require_context_helpers();
+    var utils_1 = require_utils4();
+    var diag_1 = require_diag();
+    var API_NAME = "propagation";
+    var NOOP_TEXT_MAP_PROPAGATOR = new NoopTextMapPropagator_1.NoopTextMapPropagator();
+    var PropagationAPI = class {
+      /** Empty private constructor prevents end users from constructing a new instance of the API */
+      constructor() {
+        this.createBaggage = utils_1.createBaggage;
+        this.getBaggage = context_helpers_1.getBaggage;
+        this.getActiveBaggage = context_helpers_1.getActiveBaggage;
+        this.setBaggage = context_helpers_1.setBaggage;
+        this.deleteBaggage = context_helpers_1.deleteBaggage;
+      }
+      /** Get the singleton instance of the Propagator API */
+      static getInstance() {
+        if (!this._instance) {
+          this._instance = new PropagationAPI();
+        }
+        return this._instance;
+      }
+      /**
+       * Set the current propagator.
+       *
+       * @returns true if the propagator was successfully registered, else false
+       */
+      setGlobalPropagator(propagator) {
+        return (0, global_utils_1.registerGlobal)(API_NAME, propagator, diag_1.DiagAPI.instance());
+      }
+      /**
+       * Inject context into a carrier to be propagated inter-process
+       *
+       * @param context Context carrying tracing data to inject
+       * @param carrier carrier to inject context into
+       * @param setter Function used to set values on the carrier
+       */
+      inject(context, carrier, setter = TextMapPropagator_1.defaultTextMapSetter) {
+        return this._getGlobalPropagator().inject(context, carrier, setter);
+      }
+      /**
+       * Extract context from a carrier
+       *
+       * @param context Context which the newly created context will inherit from
+       * @param carrier Carrier to extract context from
+       * @param getter Function used to extract keys from a carrier
+       */
+      extract(context, carrier, getter = TextMapPropagator_1.defaultTextMapGetter) {
+        return this._getGlobalPropagator().extract(context, carrier, getter);
+      }
+      /**
+       * Return a list of all fields which may be used by the propagator.
+       */
+      fields() {
+        return this._getGlobalPropagator().fields();
+      }
+      /** Remove the global propagator */
+      disable() {
+        (0, global_utils_1.unregisterGlobal)(API_NAME, diag_1.DiagAPI.instance());
+      }
+      _getGlobalPropagator() {
+        return (0, global_utils_1.getGlobal)(API_NAME) || NOOP_TEXT_MAP_PROPAGATOR;
+      }
+    };
+    exports.PropagationAPI = PropagationAPI;
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/propagation-api.js
+var require_propagation_api = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/propagation-api.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.propagation = void 0;
+    var propagation_1 = require_propagation();
+    exports.propagation = propagation_1.PropagationAPI.getInstance();
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/api/trace.js
+var require_trace = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/api/trace.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.TraceAPI = void 0;
+    var global_utils_1 = require_global_utils();
+    var ProxyTracerProvider_1 = require_ProxyTracerProvider();
+    var spancontext_utils_1 = require_spancontext_utils();
+    var context_utils_1 = require_context_utils();
+    var diag_1 = require_diag();
+    var API_NAME = "trace";
+    var TraceAPI = class {
+      /** Empty private constructor prevents end users from constructing a new instance of the API */
+      constructor() {
+        this._proxyTracerProvider = new ProxyTracerProvider_1.ProxyTracerProvider();
+        this.wrapSpanContext = spancontext_utils_1.wrapSpanContext;
+        this.isSpanContextValid = spancontext_utils_1.isSpanContextValid;
+        this.deleteSpan = context_utils_1.deleteSpan;
+        this.getSpan = context_utils_1.getSpan;
+        this.getActiveSpan = context_utils_1.getActiveSpan;
+        this.getSpanContext = context_utils_1.getSpanContext;
+        this.setSpan = context_utils_1.setSpan;
+        this.setSpanContext = context_utils_1.setSpanContext;
+      }
+      /** Get the singleton instance of the Trace API */
+      static getInstance() {
+        if (!this._instance) {
+          this._instance = new TraceAPI();
+        }
+        return this._instance;
+      }
+      /**
+       * Set the current global tracer.
+       *
+       * @returns true if the tracer provider was successfully registered, else false
+       */
+      setGlobalTracerProvider(provider) {
+        const success = (0, global_utils_1.registerGlobal)(API_NAME, this._proxyTracerProvider, diag_1.DiagAPI.instance());
+        if (success) {
+          this._proxyTracerProvider.setDelegate(provider);
+        }
+        return success;
+      }
+      /**
+       * Returns the global tracer provider.
+       */
+      getTracerProvider() {
+        return (0, global_utils_1.getGlobal)(API_NAME) || this._proxyTracerProvider;
+      }
+      /**
+       * Returns a tracer from the global tracer provider.
+       */
+      getTracer(name, version3) {
+        return this.getTracerProvider().getTracer(name, version3);
+      }
+      /** Remove the global tracer provider */
+      disable() {
+        (0, global_utils_1.unregisterGlobal)(API_NAME, diag_1.DiagAPI.instance());
+        this._proxyTracerProvider = new ProxyTracerProvider_1.ProxyTracerProvider();
+      }
+    };
+    exports.TraceAPI = TraceAPI;
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/trace-api.js
+var require_trace_api = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/trace-api.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.trace = void 0;
+    var trace_1 = require_trace();
+    exports.trace = trace_1.TraceAPI.getInstance();
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/index.js
+var require_src = __commonJS({
+  "../../node_modules/@opentelemetry/api/build/src/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.trace = exports.propagation = exports.metrics = exports.diag = exports.context = exports.INVALID_SPAN_CONTEXT = exports.INVALID_TRACEID = exports.INVALID_SPANID = exports.isValidSpanId = exports.isValidTraceId = exports.isSpanContextValid = exports.createTraceState = exports.TraceFlags = exports.SpanStatusCode = exports.SpanKind = exports.SamplingDecision = exports.ProxyTracerProvider = exports.ProxyTracer = exports.defaultTextMapSetter = exports.defaultTextMapGetter = exports.ValueType = exports.createNoopMeter = exports.DiagLogLevel = exports.DiagConsoleLogger = exports.ROOT_CONTEXT = exports.createContextKey = exports.baggageEntryMetadataFromString = void 0;
+    var utils_1 = require_utils4();
+    Object.defineProperty(exports, "baggageEntryMetadataFromString", { enumerable: true, get: function() {
+      return utils_1.baggageEntryMetadataFromString;
+    } });
+    var context_1 = require_context();
+    Object.defineProperty(exports, "createContextKey", { enumerable: true, get: function() {
+      return context_1.createContextKey;
+    } });
+    Object.defineProperty(exports, "ROOT_CONTEXT", { enumerable: true, get: function() {
+      return context_1.ROOT_CONTEXT;
+    } });
+    var consoleLogger_1 = require_consoleLogger();
+    Object.defineProperty(exports, "DiagConsoleLogger", { enumerable: true, get: function() {
+      return consoleLogger_1.DiagConsoleLogger;
+    } });
+    var types_1 = require_types();
+    Object.defineProperty(exports, "DiagLogLevel", { enumerable: true, get: function() {
+      return types_1.DiagLogLevel;
+    } });
+    var NoopMeter_1 = require_NoopMeter();
+    Object.defineProperty(exports, "createNoopMeter", { enumerable: true, get: function() {
+      return NoopMeter_1.createNoopMeter;
+    } });
+    var Metric_1 = require_Metric();
+    Object.defineProperty(exports, "ValueType", { enumerable: true, get: function() {
+      return Metric_1.ValueType;
+    } });
+    var TextMapPropagator_1 = require_TextMapPropagator();
+    Object.defineProperty(exports, "defaultTextMapGetter", { enumerable: true, get: function() {
+      return TextMapPropagator_1.defaultTextMapGetter;
+    } });
+    Object.defineProperty(exports, "defaultTextMapSetter", { enumerable: true, get: function() {
+      return TextMapPropagator_1.defaultTextMapSetter;
+    } });
+    var ProxyTracer_1 = require_ProxyTracer();
+    Object.defineProperty(exports, "ProxyTracer", { enumerable: true, get: function() {
+      return ProxyTracer_1.ProxyTracer;
+    } });
+    var ProxyTracerProvider_1 = require_ProxyTracerProvider();
+    Object.defineProperty(exports, "ProxyTracerProvider", { enumerable: true, get: function() {
+      return ProxyTracerProvider_1.ProxyTracerProvider;
+    } });
+    var SamplingResult_1 = require_SamplingResult();
+    Object.defineProperty(exports, "SamplingDecision", { enumerable: true, get: function() {
+      return SamplingResult_1.SamplingDecision;
+    } });
+    var span_kind_1 = require_span_kind();
+    Object.defineProperty(exports, "SpanKind", { enumerable: true, get: function() {
+      return span_kind_1.SpanKind;
+    } });
+    var status_1 = require_status();
+    Object.defineProperty(exports, "SpanStatusCode", { enumerable: true, get: function() {
+      return status_1.SpanStatusCode;
+    } });
+    var trace_flags_1 = require_trace_flags();
+    Object.defineProperty(exports, "TraceFlags", { enumerable: true, get: function() {
+      return trace_flags_1.TraceFlags;
+    } });
+    var utils_2 = require_utils5();
+    Object.defineProperty(exports, "createTraceState", { enumerable: true, get: function() {
+      return utils_2.createTraceState;
+    } });
+    var spancontext_utils_1 = require_spancontext_utils();
+    Object.defineProperty(exports, "isSpanContextValid", { enumerable: true, get: function() {
+      return spancontext_utils_1.isSpanContextValid;
+    } });
+    Object.defineProperty(exports, "isValidTraceId", { enumerable: true, get: function() {
+      return spancontext_utils_1.isValidTraceId;
+    } });
+    Object.defineProperty(exports, "isValidSpanId", { enumerable: true, get: function() {
+      return spancontext_utils_1.isValidSpanId;
+    } });
+    var invalid_span_constants_1 = require_invalid_span_constants();
+    Object.defineProperty(exports, "INVALID_SPANID", { enumerable: true, get: function() {
+      return invalid_span_constants_1.INVALID_SPANID;
+    } });
+    Object.defineProperty(exports, "INVALID_TRACEID", { enumerable: true, get: function() {
+      return invalid_span_constants_1.INVALID_TRACEID;
+    } });
+    Object.defineProperty(exports, "INVALID_SPAN_CONTEXT", { enumerable: true, get: function() {
+      return invalid_span_constants_1.INVALID_SPAN_CONTEXT;
+    } });
+    var context_api_1 = require_context_api();
+    Object.defineProperty(exports, "context", { enumerable: true, get: function() {
+      return context_api_1.context;
+    } });
+    var diag_api_1 = require_diag_api();
+    Object.defineProperty(exports, "diag", { enumerable: true, get: function() {
+      return diag_api_1.diag;
+    } });
+    var metrics_api_1 = require_metrics_api();
+    Object.defineProperty(exports, "metrics", { enumerable: true, get: function() {
+      return metrics_api_1.metrics;
+    } });
+    var propagation_api_1 = require_propagation_api();
+    Object.defineProperty(exports, "propagation", { enumerable: true, get: function() {
+      return propagation_api_1.propagation;
+    } });
+    var trace_api_1 = require_trace_api();
+    Object.defineProperty(exports, "trace", { enumerable: true, get: function() {
+      return trace_api_1.trace;
+    } });
+    exports.default = {
+      context: context_api_1.context,
+      diag: diag_api_1.diag,
+      metrics: metrics_api_1.metrics,
+      propagation: propagation_api_1.propagation,
+      trace: trace_api_1.trace
+    };
+  }
+});
+
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
@@ -56088,6 +57736,8 @@ var TransactionError = class extends import_dx_common_lib2.InternalServerError {
 };
 
 // src/dynamodb/DynamoDbManager.ts
+var import_api = __toESM(require_src());
+var tracer = import_api.trace.getTracer("db-lib:DynamoDbManager");
 var DynamoDbManager = class {
   constructor(client, repositoryCreator) {
     this.client = client;
@@ -56115,10 +57765,24 @@ var DynamoDbManager = class {
     if (this.transactionItems[transactionId] === void 0) {
       throw new TransactionError(`No items in transaction '${transactionId}' to execute`);
     }
-    return await this.client.transactWrite({
-      ClientRequestToken: transactionId,
-      TransactItems: this.transactionItems[transactionId]
-    });
+    return tracer.startActiveSpan(
+      "executeTransaction",
+      {
+        attributes: {
+          "transactionItems.length": this.transactionItems[transactionId].length
+        }
+      },
+      async (span) => {
+        try {
+          return await this.client.transactWrite({
+            ClientRequestToken: transactionId,
+            TransactItems: this.transactionItems[transactionId]
+          });
+        } finally {
+          span.end();
+        }
+      }
+    );
   }
   startTransaction(transactionId) {
     if (this.transactionItems[transactionId] !== void 0) {
@@ -56131,6 +57795,15 @@ var DynamoDbManager = class {
   }
 };
 
+// src/error/InvalidDataFormatError.ts
+var import_dx_common_lib3 = __toESM(require_lib5());
+var InvalidDataFormatError = class extends import_dx_common_lib3.InternalServerError {
+  constructor(message) {
+    super(message);
+    this.name = "InvalidDataFormatError";
+  }
+};
+
 // src/dynamodb/AbstractDynamoDbRepository.ts
 var AbstractDynamoDbRepository = class {
   constructor(tableName, dbManager, entityName2, entityDefinition, classRef) {
@@ -56142,6 +57815,7 @@ var AbstractDynamoDbRepository = class {
     this.client = dbManager.client;
     this.keys = entityDefinition.keys;
     this.indexes = entityDefinition.indexes;
+    this.fieldsAsJsonString = entityDefinition.fieldsAsJsonString;
     this.keysFormat = {
       [this.keys.pk.attributeName]: this.keys.pk.format,
       [this.keys.sk.attributeName]: this.keys.sk.format
@@ -56233,7 +57907,9 @@ var AbstractDynamoDbRepository = class {
     if (oldValue === void 0) {
       return void 0;
     }
-    this.assertValueMatchesModel({ ...oldValue, ...newValue });
+    const value = { ...oldValue, ...newValue };
+    this.assertValueMatchesModel(value);
+    this.convertSelectedValuesToJsonString(newValue);
     const updateExpression = [];
     const expressionAttributeNames = {};
     const expressionAttributeValues = {};
@@ -56259,7 +57935,7 @@ var AbstractDynamoDbRepository = class {
       this.dbManager.addWriteTransactionItem(transaction.id, {
         Update: updateCommandInput
       });
-      return new this.classRef({ ...oldValue, ...newValue });
+      return new this.classRef(value);
     }
     let output;
     try {
@@ -56296,6 +57972,7 @@ var AbstractDynamoDbRepository = class {
     for (const modelProperty of Object.keys(value)) {
       columns[modelProperty] = value[modelProperty];
     }
+    this.convertSelectedValuesToJsonString(columns);
     const keyFields = {
       [this.keys.pk.attributeName]: this.getPk(value),
       [this.keys.sk.attributeName]: this.getSk(value)
@@ -56362,8 +58039,24 @@ var AbstractDynamoDbRepository = class {
    * @returns
    */
   hydrateItem(item) {
+    for (const fieldName of Object.keys(item)) {
+      if (this.fieldsAsJsonString.includes(fieldName)) {
+        if (typeof item[fieldName] === "string") {
+          item[fieldName] = JSON.parse(item[fieldName]);
+        } else {
+          throw new InvalidDataFormatError(`Field '${fieldName}' defined as JSON String has a non-string data`);
+        }
+      }
+    }
     return new this.classRef(item);
   }
+  convertSelectedValuesToJsonString(item) {
+    for (const fieldName of Object.keys(item)) {
+      if (this.fieldsAsJsonString.includes(fieldName)) {
+        item[fieldName] = JSON.stringify(item[fieldName]);
+      }
+    }
+  }
   /**
    * Evaluate the partition key value from the partial item
    * @param item
@@ -56502,8 +58195,8 @@ async function getSecret(id) {
 }
 
 // src/error/DuplicateItemError.ts
-var import_dx_common_lib3 = __toESM(require_lib5());
-var DuplicateItemError = class extends import_dx_common_lib3.InternalServerError {
+var import_dx_common_lib4 = __toESM(require_lib5());
+var DuplicateItemError = class extends import_dx_common_lib4.InternalServerError {
   constructor(message) {
     super(message);
     this.name = "DuplicateItemError";
@@ -56511,8 +58204,8 @@ var DuplicateItemError = class extends import_dx_common_lib3.InternalServerError
 };
 
 // src/error/MissingKeyValuesError.ts
-var import_dx_common_lib4 = __toESM(require_lib5());
-var MissingKeyValuesError = class extends import_dx_common_lib4.InternalServerError {
+var import_dx_common_lib5 = __toESM(require_lib5());
+var MissingKeyValuesError = class extends import_dx_common_lib5.InternalServerError {
   constructor(message) {
     super(message);
     this.name = "MissingKeyValuesError";
@@ -56520,8 +58213,8 @@ var MissingKeyValuesError = class extends import_dx_common_lib4.InternalServerEr
 };
 
 // src/error/InvalidDbSchemaError.ts
-var import_dx_common_lib5 = __toESM(require_lib5());
-var InvalidDbSchemaError = class extends import_dx_common_lib5.BadRequestError {
+var import_dx_common_lib6 = __toESM(require_lib5());
+var InvalidDbSchemaError = class extends import_dx_common_lib6.BadRequestError {
   constructor(message) {
     super(message);
     this.name = "InvalidDbSchemaError";