@baselime/trpc-opentelemetry-middleware/dist/index.cjs

Instrument your TRPC Application with OpenTelemetry

var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/index.ts
var src_exports = {};
__export(src_exports, {
  tracing: () => tracing
});
module.exports = __toCommonJS(src_exports);
var import_api = require("@opentelemetry/api");
var import_server = require("@trpc/server");

// node_modules/flat/index.js
function isBuffer(obj) {
  return obj && obj.constructor && typeof obj.constructor.isBuffer === "function" && obj.constructor.isBuffer(obj);
}
function keyIdentity(key) {
  return key;
}
function flatten(target, opts) {
  opts = opts || {};
  const delimiter = opts.delimiter || ".";
  const maxDepth = opts.maxDepth;
  const transformKey = opts.transformKey || keyIdentity;
  const output = {};
  function step(object, prev, currentDepth) {
    currentDepth = currentDepth || 1;
    Object.keys(object).forEach(function(key) {
      const value = object[key];
      const isarray = opts.safe && Array.isArray(value);
      const type = Object.prototype.toString.call(value);
      const isbuffer = isBuffer(value);
      const isobject = type === "[object Object]" || type === "[object Array]";
      const newKey = prev ? prev + delimiter + transformKey(key) : transformKey(key);
      if (!isarray && !isbuffer && isobject && Object.keys(value).length && (!opts.maxDepth || currentDepth < maxDepth)) {
        return step(value, newKey, currentDepth + 1);
      }
      output[newKey] = value;
    });
  }
  step(target);
  return output;
}

// src/index.ts
function tracing(options) {
  const tracer = import_api.trace.getTracer("@baselime/trpc");
  options = options || {};
  return (0, import_server.experimental_standaloneMiddleware)().create(async (opts) => {
    return tracer.startActiveSpan(`TRPC ${opts.type}`, async (span) => {
      const result = await opts.next();
      if (options.collectInput && typeof opts.rawInput === "object") {
        span.setAttributes(flatten({ input: opts.rawInput }));
      }
      const meta = { path: opts.path, type: opts.type, ok: result.ok };
      span.setAttributes(meta);
      span.end();
      return result;
    });
  });
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  tracing
});