@ms-cloudpack/telemetry 0.8.1 → 0.8.2

package/dist/{AppInsightsTelemetryClient-R4KUMXIS.js → AppInsightsTelemetryClient-DIN7NSX7.js}

@@ -21,7 +21,7 @@ import {
   require_src2,
   require_src3,
   require_src4
-} from "./chunk-NJ4KSOZ3.js";
+} from "./chunk-6K6C2B4T.js";
 
 // ../../node_modules/.store/@azure-core-rest-pipeline-npm-1.17.0-aa1ea9ace7/package/dist/commonjs/pipeline.js
 var require_pipeline = __commonJS({

package/dist/{NoOpTelemetryClient-TTBAN54Z.js → NoOpTelemetryClient-IZOMUV4R.js}

@@ -6,8 +6,8 @@ const __filename = topLevelUrl.fileURLToPath(import.meta.url);
 const __dirname = topLevelPath.dirname(__filename);
 import {
   NoOpTelemetryClient
-} from "./chunk-BNPQM6Z3.js";
-import "./chunk-NJ4KSOZ3.js";
+} from "./chunk-7OGMQ6JV.js";
+import "./chunk-6K6C2B4T.js";
 export {
   NoOpTelemetryClient
 };

package/dist/{chunk-NJ4KSOZ3.js → chunk-6K6C2B4T.js}

@@ -12405,6 +12405,108 @@ var _ConsoleSpanExporter = class _ConsoleSpanExporter {
 __name(_ConsoleSpanExporter, "ConsoleSpanExporter");
 var ConsoleSpanExporter = _ConsoleSpanExporter;
 
+// src/proxies/createEndGuardedSpan.ts
+var hasEnded = Symbol("hasEnded");
+function createEndGuardedSpan(span) {
+  return new Proxy(span, {
+    get(target, prop) {
+      if (prop === "hasEnded") {
+        return () => !!Reflect.get(target, hasEnded);
+      }
+      if (prop === "end") {
+        return () => {
+          if (!Reflect.get(target, hasEnded)) {
+            target.end();
+            Reflect.set(target, hasEnded, true);
+          }
+        };
+      }
+      return Reflect.get(target, prop);
+    },
+    set(target, prop, value) {
+      if (prop === "end") {
+        throw new Error("Cannot overwrite 'end' method on Span.");
+      }
+      return Reflect.set(target, prop, value);
+    }
+  });
+}
+__name(createEndGuardedSpan, "createEndGuardedSpan");
+
+// src/proxies/createSpanFunctionWrapper.ts
+function createSpanFunctionWrapper(fn) {
+  return function(span) {
+    const guardedSpan = createEndGuardedSpan(span);
+    try {
+      return fn(guardedSpan);
+    } catch (error) {
+      if (!guardedSpan.hasEnded()) {
+        guardedSpan.recordException(error instanceof Error || typeof error === "string" ? error : String(error));
+      } else {
+        console.info("OpenTelemetry:startActiveSpan: span has already ended, skipping recording exception.");
+      }
+      throw error;
+    } finally {
+      guardedSpan.end();
+    }
+  };
+}
+__name(createSpanFunctionWrapper, "createSpanFunctionWrapper");
+
+// src/proxies/createImprovedStartActiveSpan.ts
+function parseParameters(...params) {
+  const [name, optionsOrFn, contextOrFn, maybeFn] = params;
+  if (params.length === 2) {
+    return { name, fn: optionsOrFn };
+  }
+  if (params.length === 3) {
+    return { name, options: optionsOrFn, fn: contextOrFn };
+  }
+  if (params.length === 4) {
+    return {
+      name,
+      options: optionsOrFn,
+      context: contextOrFn,
+      fn: maybeFn
+    };
+  }
+  throw new Error("Number of arguments is not supported for startActiveSpan");
+}
+__name(parseParameters, "parseParameters");
+function createImprovedStartActiveSpan(target) {
+  return (...params) => {
+    const { fn, name, context: context2, options } = parseParameters(...params);
+    const wrappedSpanFunction = createSpanFunctionWrapper(fn);
+    if (context2) {
+      return target.startActiveSpan(name, options, context2, wrappedSpanFunction);
+    }
+    if (options) {
+      return target.startActiveSpan(name, options, wrappedSpanFunction);
+    }
+    return target.startActiveSpan(name, wrappedSpanFunction);
+  };
+}
+__name(createImprovedStartActiveSpan, "createImprovedStartActiveSpan");
+
+// src/proxies/createProxiedTracer.ts
+var isProxy = Symbol("isProxy");
+function createProxiedTracer(tracer) {
+  if (Reflect.has(tracer, isProxy)) {
+    return tracer;
+  }
+  const proxiedTracer = new Proxy(tracer, {
+    get(target, prop) {
+      if (prop === "startActiveSpan") {
+        return createImprovedStartActiveSpan(target);
+      }
+      return Reflect.get(target, prop);
+    }
+  });
+  Reflect.set(proxiedTracer, isProxy, true);
+  return proxiedTracer;
+}
+__name(createProxiedTracer, "createProxiedTracer");
+
 // src/BaseTelemetryClient.ts
 var _BaseTelemetryClient = class _BaseTelemetryClient {
   constructor(options) {
@@ -12444,7 +12546,7 @@ var _BaseTelemetryClient = class _BaseTelemetryClient {
    * @returns the OpenTelemetry tracer
    */
   get tracer() {
-    return this._tracerProvider.getTracer("cloudpack-tracer");
+    return createProxiedTracer(this._tracerProvider.getTracer("cloudpack-tracer"));
   }
   get performance() {
     return this._performance;

package/dist/{chunk-BNPQM6Z3.js → chunk-7OGMQ6JV.js}

@@ -7,7 +7,7 @@ const __dirname = topLevelPath.dirname(__filename);
 import {
   BaseTelemetryClient,
   __name
-} from "./chunk-NJ4KSOZ3.js";
+} from "./chunk-6K6C2B4T.js";
 
 // src/NoOpTelemetryClient.ts
 var _NoOpTelemetryClient = class _NoOpTelemetryClient extends BaseTelemetryClient {

package/dist/index.js

@@ -6,28 +6,28 @@ const __filename = topLevelUrl.fileURLToPath(import.meta.url);
 const __dirname = topLevelPath.dirname(__filename);
 import {
   NoOpTelemetryClient
-} from "./chunk-BNPQM6Z3.js";
+} from "./chunk-7OGMQ6JV.js";
 import {
   DiagConsoleLogger,
   DiagLogLevel,
   __name,
   diag,
   init_esm
-} from "./chunk-NJ4KSOZ3.js";
+} from "./chunk-6K6C2B4T.js";
 
 // src/createTelemetryClient.ts
 init_esm();
 async function createTelemetryClient(options) {
   if (!options.connectionString) {
     console.debug("No connection string found. Telemetry will not be sent.");
-    const { NoOpTelemetryClient: NoOpTelemetryClient2 } = await import("./NoOpTelemetryClient-TTBAN54Z.js");
+    const { NoOpTelemetryClient: NoOpTelemetryClient2 } = await import("./NoOpTelemetryClient-IZOMUV4R.js");
     return new NoOpTelemetryClient2();
   }
   diag.setLogger(new DiagConsoleLogger(), {
     logLevel: options.logLevel || DiagLogLevel.WARN,
     suppressOverrideMessage: true
   });
-  const { AppInsightsTelemetryClient } = await import("./AppInsightsTelemetryClient-R4KUMXIS.js");
+  const { AppInsightsTelemetryClient } = await import("./AppInsightsTelemetryClient-DIN7NSX7.js");
   return new AppInsightsTelemetryClient(options);
 }
 __name(createTelemetryClient, "createTelemetryClient");

package/lib/proxies/createEndGuardedSpan.d.ts

@@ -0,0 +1,12 @@
+import type { Span } from '@opentelemetry/api';
+/**
+ * A span that can be ended only once
+ */
+export type EndGuardedSpan = Span & {
+    hasEnded: () => boolean;
+};
+/**
+ * Wraps a Span in a Proxy to intercept calls to `end` and ensure it’s only called once.
+ */
+export declare function createEndGuardedSpan(span: Span): EndGuardedSpan;
+//# sourceMappingURL=createEndGuardedSpan.d.ts.map

package/lib/proxies/createEndGuardedSpan.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=createEndGuardedSpan.test.d.ts.map

package/lib/proxies/createImprovedStartActiveSpan.d.ts

@@ -0,0 +1,4 @@
+import type { Tracer, Span, SpanOptions, Context } from '@opentelemetry/api';
+export type SpanFunction<T> = (span: Span) => T;
+export declare function createImprovedStartActiveSpan(target: Tracer): <T>(name: string, optionsOrFn?: SpanOptions | SpanFunction<unknown> | undefined, contextOrFn?: Context | SpanFunction<unknown> | undefined, maybeFn?: SpanFunction<unknown> | undefined) => T;
+//# sourceMappingURL=createImprovedStartActiveSpan.d.ts.map

package/lib/proxies/createImprovedStartActiveSpan.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=createImprovedStartActiveSpan.test.d.ts.map

package/lib/proxies/createProxiedTracer.d.ts

@@ -0,0 +1,10 @@
+import type { Tracer } from '@opentelemetry/api';
+/**
+ * Creates a proxied tracer that will automatically do the following things;
+ *  - End the span when the function ends
+ *  - Record any exceptions that are thrown
+ * @param tracer - The tracer to proxy
+ * @returns - Proxied tracer
+ */
+export declare function createProxiedTracer(tracer: Tracer): Tracer;
+//# sourceMappingURL=createProxiedTracer.d.ts.map

package/lib/proxies/createProxiedTracer.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=createProxiedTracer.test.d.ts.map

package/lib/proxies/createSpanFunctionWrapper.d.ts

@@ -0,0 +1,9 @@
+import type { Span } from '@opentelemetry/api';
+import type { SpanFunction } from './createImprovedStartActiveSpan.js';
+/**
+ * Wraps a span function to ensure that the span is ended and any exceptions are recorded.
+ * @param fn - The span function to wrap
+ * @returns - Wrapped span function
+ */
+export declare function createSpanFunctionWrapper<T>(fn: SpanFunction<T>): (span: Span) => T;
+//# sourceMappingURL=createSpanFunctionWrapper.d.ts.map

package/lib/proxies/createSpanFunctionWrapper.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=createSpanFunctionWrapper.test.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ms-cloudpack/telemetry",
-  "version": "0.8.1",
+  "version": "0.8.2",
   "description": "Helpers for reporting telemetry in Cloudpack.",
   "license": "MIT",
   "type": "module",
@@ -16,7 +16,7 @@
   "devDependencies": {
     "@azure/monitor-opentelemetry-exporter": "1.0.0-beta.26",
     "@ms-cloudpack/eslint-plugin-internal": "^0.0.1",
-    "@ms-cloudpack/package-utilities": "^10.2.7",
+    "@ms-cloudpack/package-utilities": "^10.2.8",
     "@ms-cloudpack/scripts": "^0.0.1",
     "@opentelemetry/api": "~1.9.0",
     "@opentelemetry/core": "~1.26.0",
@@ -32,7 +32,10 @@
     "build:watch": "cloudpack-scripts build-watch",
     "build": "cloudpack-scripts build && cloudpack-scripts bundle-node",
     "lint:update": "cloudpack-scripts lint-update",
-    "lint": "cloudpack-scripts lint"
+    "lint": "cloudpack-scripts lint",
+    "test:update": "cloudpack-scripts test-update",
+    "test:watch": "cloudpack-scripts test-watch",
+    "test": "cloudpack-scripts test"
   },
   "files": [
     "dist",