@ms-cloudpack/telemetry 0.8.0 → 0.8.2

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

@@ -21,7 +21,7 @@ import {
   require_src2,
   require_src3,
   require_src4
-} from "./chunk-NCK3Y7B7.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-M2CYNHPI.js → NoOpTelemetryClient-IZOMUV4R.js}

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

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

@@ -4965,11 +4965,11 @@ var require_ExportResult = __commonJS({
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.ExportResultCode = void 0;
-    var ExportResultCode;
-    (function(ExportResultCode2) {
-      ExportResultCode2[ExportResultCode2["SUCCESS"] = 0] = "SUCCESS";
-      ExportResultCode2[ExportResultCode2["FAILED"] = 1] = "FAILED";
-    })(ExportResultCode = exports.ExportResultCode || (exports.ExportResultCode = {}));
+    var ExportResultCode2;
+    (function(ExportResultCode3) {
+      ExportResultCode3[ExportResultCode3["SUCCESS"] = 0] = "SUCCESS";
+      ExportResultCode3[ExportResultCode3["FAILED"] = 1] = "FAILED";
+    })(ExportResultCode2 = exports.ExportResultCode || (exports.ExportResultCode = {}));
   }
 });
 
@@ -6988,8 +6988,8 @@ var require_BatchSpanProcessor = __commonJS({
       }
     };
     __name(_BatchSpanProcessor, "BatchSpanProcessor");
-    var BatchSpanProcessor = _BatchSpanProcessor;
-    exports.BatchSpanProcessor = BatchSpanProcessor;
+    var BatchSpanProcessor2 = _BatchSpanProcessor;
+    exports.BatchSpanProcessor = BatchSpanProcessor2;
   }
 });
 
@@ -8418,7 +8418,7 @@ var require_ConsoleSpanExporter = __commonJS({
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.ConsoleSpanExporter = void 0;
     var core_1 = require_src2();
-    var _ConsoleSpanExporter = class _ConsoleSpanExporter {
+    var _ConsoleSpanExporter2 = class _ConsoleSpanExporter2 {
       /**
        * Export spans.
        * @param spans
@@ -8479,9 +8479,9 @@ var require_ConsoleSpanExporter = __commonJS({
         }
       }
     };
-    __name(_ConsoleSpanExporter, "ConsoleSpanExporter");
-    var ConsoleSpanExporter = _ConsoleSpanExporter;
-    exports.ConsoleSpanExporter = ConsoleSpanExporter;
+    __name(_ConsoleSpanExporter2, "ConsoleSpanExporter");
+    var ConsoleSpanExporter2 = _ConsoleSpanExporter2;
+    exports.ConsoleSpanExporter = ConsoleSpanExporter2;
   }
 });
 
@@ -12359,6 +12359,154 @@ function getVersion(importUrl) {
 }
 __name(getVersion, "getVersion");
 
+// src/ConsoleSpanExporter.ts
+var import_core = __toESM(require_src2(), 1);
+var _ConsoleSpanExporter = class _ConsoleSpanExporter {
+  /**
+   * Export spans.
+   */
+  export(spans, resultCallback) {
+    return this._sendSpans(spans, resultCallback);
+  }
+  /**
+   * Shutdown the exporter.
+   */
+  shutdown() {
+    this._sendSpans([]);
+    return this.forceFlush();
+  }
+  /**
+   * Exports any pending spans in exporter
+   */
+  forceFlush() {
+    return Promise.resolve();
+  }
+  /**
+   * converts span info into more readable format
+   */
+  _exportInfo(span) {
+    return [
+      `Telemetry Span: ${span.name} in ${span.duration}ms`,
+      span.events.length > 0 ? `with ${span.events.length} events` : void 0
+    ].filter((text) => !!text).join(" ");
+  }
+  /**
+   * Showing spans in console
+   */
+  _sendSpans(spans, done) {
+    for (const span of spans) {
+      console.debug(this._exportInfo(span));
+    }
+    if (done) {
+      return done({ code: import_core.ExportResultCode.SUCCESS });
+    }
+  }
+};
+__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) {
@@ -12375,6 +12523,9 @@ var _BaseTelemetryClient = class _BaseTelemetryClient {
         "cloudpack.telemetry.version": getVersion(import.meta.url)
       })
     );
+    if (options.logLevel === "DEBUG") {
+      this._tracerProvider.addSpanProcessor(new import_sdk_trace_node.BatchSpanProcessor(new ConsoleSpanExporter()));
+    }
     this._rootSpan = this.tracer.startSpan(options.rootSpanName || "root");
     this._performance = new PerformanceRecorder(this._rootSpan);
     diag2.info("TelemetryClient is initialized.");
@@ -12395,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-6ZXUGFN2.js → chunk-7OGMQ6JV.js}

@@ -7,7 +7,7 @@ const __dirname = topLevelPath.dirname(__filename);
 import {
   BaseTelemetryClient,
   __name
-} from "./chunk-NCK3Y7B7.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-6ZXUGFN2.js";
+} from "./chunk-7OGMQ6JV.js";
 import {
   DiagConsoleLogger,
   DiagLogLevel,
   __name,
   diag,
   init_esm
-} from "./chunk-NCK3Y7B7.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-M2CYNHPI.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-VHBDVKM4.js");
+  const { AppInsightsTelemetryClient } = await import("./AppInsightsTelemetryClient-DIN7NSX7.js");
   return new AppInsightsTelemetryClient(options);
 }
 __name(createTelemetryClient, "createTelemetryClient");

package/lib/ConsoleSpanExporter.d.ts

@@ -0,0 +1,37 @@
+/**
+ * A customized version of the OpenTelemetry `ConsoleSpanExporter`.
+ * Original source: https://github.com/open-telemetry/opentelemetry-js/blob/main/packages/opentelemetry-sdk-trace-base/src/export/ConsoleSpanExporter.ts
+ *
+ * This modified exporter adjusts the format of the output for improved readability.
+ */
+import type { ReadableSpan, SpanExporter } from '@opentelemetry/sdk-trace-base';
+import type { ExportResult } from '@opentelemetry/core';
+/**
+ * This is implementation of {@link SpanExporter} that prints spans to the
+ * console. This class can be used for diagnostic purposes.
+ *
+ * NOTE: This {@link SpanExporter} is intended for diagnostics use only, output rendered to the console may change at any time.
+ */
+export declare class ConsoleSpanExporter implements SpanExporter {
+    /**
+     * Export spans.
+     */
+    export(spans: ReadableSpan[], resultCallback: (result: ExportResult) => void): void;
+    /**
+     * Shutdown the exporter.
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Exports any pending spans in exporter
+     */
+    forceFlush(): Promise<void>;
+    /**
+     * converts span info into more readable format
+     */
+    private _exportInfo;
+    /**
+     * Showing spans in console
+     */
+    private _sendSpans;
+}
+//# sourceMappingURL=ConsoleSpanExporter.d.ts.map

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.0",
+  "version": "0.8.2",
   "description": "Helpers for reporting telemetry in Cloudpack.",
   "license": "MIT",
   "type": "module",
@@ -16,9 +16,10 @@
   "devDependencies": {
     "@azure/monitor-opentelemetry-exporter": "1.0.0-beta.26",
     "@ms-cloudpack/eslint-plugin-internal": "^0.0.1",
-    "@ms-cloudpack/package-utilities": "^10.2.6",
+    "@ms-cloudpack/package-utilities": "^10.2.8",
     "@ms-cloudpack/scripts": "^0.0.1",
     "@opentelemetry/api": "~1.9.0",
+    "@opentelemetry/core": "~1.26.0",
     "@opentelemetry/resources": "~1.26.0",
     "@opentelemetry/sdk-trace-base": "~1.26.0",
     "@opentelemetry/sdk-trace-node": "~1.26.0",
@@ -31,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",