@pagopa/azure-tracing 0.4.1-beta.0 → 0.4.2

package/README.md

@@ -15,6 +15,8 @@ yarn add @pagopa/azure-tracing
 
 ### Instrumenting Azure Functions
 
+To enable OpenTelemetry tracing and route telemetry to Azure Monitor in your Azure Functions (both v3 and v4 programming models), you primarily need to perform two steps: preload the instrumentation logic via `NODE_OPTIONS` and register lifecycle hooks.
+
 Currently, [ECMAScript Modules (ESM) support in OpenTelemetry is still experimental](https://github.com/open-telemetry/opentelemetry-js/blob/966ac176af249d86de6cb10feac2306062846768/doc/esm-support.md),
 which makes direct instrumentation of Azure Functions a bit tricky.
 So, if you have a Node.js project ESM based (`"type": "module"` in the `package.json`), to work around this, you have to preload the instrumentation logic at runtime using the `NODE_OPTIONS` environment variable.
@@ -70,15 +72,9 @@ registerAzureFunctionHooks(app);
 
 ### Instrumenting Azure Functions v3 Handlers
 
-For Azure Functions using the v3 programming model, the recommended way to enable OpenTelemetry tracing is to use the `NODE_OPTIONS` environment variable, just like for v4 functions:
+For Azure Functions using the v3 programming model, if you need more granular control over OpenTelemetry context propagation within your function handlers, you can use the `withOtelContextFunctionV3` helper function to wrap your handlers. This function is designed to work with the v3 `Context` object structure.
 
-```bash
-NODE_OPTIONS=--import @pagopa/azure-tracing
-```
-
-This will automatically enable OpenTelemetry tracing and route telemetry to Azure Monitor.
-
-Then, wrap the execution of the Azure function in the OpenTelemetry context; take inspiration from the following code snippet:
+To wrap the execution of your Azure Function in the OpenTelemetry context, use the `withOtelContextFunctionV3` helper as follows:
 
 ```ts
 import { AzureFunction, Context as FunctionContext } from "@azure/functions"; // "@azure/functions": "^3"
@@ -95,6 +91,9 @@ export const expressToAzureFunction =
 
 ### Enabling Azure Monitor Telemetry
 
+> [!NOTE]
+> For Azure Functions, it is necessary to use the `NODE_OPTIONS` environment variable and register lifecycle hooks as described in the "Instrumenting Azure Functions" section. Manual initialization with `initAzureMonitor` is typically not required for Azure Functions (due to the issue previously explained), but it is useful for other Node.js applications (e.g., Azure App Services) where direct SDK initialization is preferred or necessary.
+
 If you want to enable Azure Monitor telemetry in your application, and you don't have those issues previously described, you can do so in the following ways:
 
 ```ts
@@ -108,17 +107,6 @@ initAzureMonitor(instrumentations, config);
 ...
 ```
 
-> [!NOTE]
-> the use of `ExpressInstrumentation` is just for example, you can use any other OpenTelemetry instrumentation you want.
-
-or, if you want to use the default configuration:
-
-```ts
-import { initAzureMonitor } from "@pagopa/azure-tracing/azure-monitor";
-...
-initAzureMonitor();
-```
-
 ### Logging Custom Events
 
 You can log custom events for additional observability using the `emitCustomEvent` function.

package/dist/functions/hooks.d.ts

@@ -0,0 +1,22 @@
+import { app } from '@azure/functions';
+
+/**
+ * Registers Azure Function hooks to enable OpenTelemetry tracing.
+ * These hooks extract trace context from the Azure Function context
+ * and bind it to the function handler, ensuring that traces are
+ * properly propagated across function invocations.
+ *
+ * Once the issues that causes this workaround are resolved, it will be possible
+ * to add the [azure-functions-nodejs-opentelemetry](https://github.com/Azure/azure-functions-nodejs-opentelemetry/tree/main)
+ * to the instrumentation package and remove this workaround.
+ *
+ * @example
+ * In your application, where you add the Azure Functions hooks (like `app.http() and so on), you
+ * can add the following code:
+ *
+ * registerAzureFunctionHooks(app);
+ *
+ */
+declare const registerAzureFunctionHooks: ({ hook }: typeof app) => void;
+
+export { registerAzureFunctionHooks };

package/dist/functions/hooks.js

@@ -0,0 +1,20 @@
+// src/azure/functions/hooks.ts
+import { context as otelContext, propagation } from "@opentelemetry/api";
+var registerAzureFunctionHooks = ({ hook }) => {
+  hook.preInvocation((context) => {
+    const traceContext = context.invocationContext.traceContext;
+    if (traceContext) {
+      context.functionHandler = otelContext.bind(
+        propagation.extract(otelContext.active(), {
+          traceparent: traceContext.traceParent,
+          tracestate: traceContext.traceState
+        }),
+        context.functionHandler
+      );
+    }
+  });
+};
+export {
+  registerAzureFunctionHooks
+};
+//# sourceMappingURL=hooks.js.map

package/dist/functions/hooks.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/azure/functions/hooks.ts"],"sourcesContent":["import { app } from \"@azure/functions\";\nimport { context as otelContext, propagation } from \"@opentelemetry/api\";\n\n/**\n * Registers Azure Function hooks to enable OpenTelemetry tracing.\n * These hooks extract trace context from the Azure Function context\n * and bind it to the function handler, ensuring that traces are\n * properly propagated across function invocations.\n *\n * Once the issues that causes this workaround are resolved, it will be possible\n * to add the [azure-functions-nodejs-opentelemetry](https://github.com/Azure/azure-functions-nodejs-opentelemetry/tree/main)\n * to the instrumentation package and remove this workaround.\n *\n * @example\n * In your application, where you add the Azure Functions hooks (like `app.http() and so on), you\n * can add the following code:\n *\n * registerAzureFunctionHooks(app);\n *\n */\nexport const registerAzureFunctionHooks = ({ hook }: typeof app) => {\n  hook.preInvocation((context) => {\n    const traceContext = context.invocationContext.traceContext;\n    if (traceContext) {\n      context.functionHandler = otelContext.bind(\n        propagation.extract(otelContext.active(), {\n          traceparent: traceContext.traceParent,\n          tracestate: traceContext.traceState,\n        }),\n        context.functionHandler,\n      );\n    }\n  });\n};\n"],"mappings":";AACA,SAAS,WAAW,aAAa,mBAAmB;AAmB7C,IAAM,6BAA6B,CAAC,EAAE,KAAK,MAAkB;AAClE,OAAK,cAAc,CAAC,YAAY;AAC9B,UAAM,eAAe,QAAQ,kBAAkB;AAC/C,QAAI,cAAc;AAChB,cAAQ,kBAAkB,YAAY;AAAA,QACpC,YAAY,QAAQ,YAAY,OAAO,GAAG;AAAA,UACxC,aAAa,aAAa;AAAA,UAC1B,YAAY,aAAa;AAAA,QAC3B,CAAC;AAAA,QACD,QAAQ;AAAA,MACV;AAAA,IACF;AAAA,EACF,CAAC;AACH;","names":[]}

package/dist/functions/index.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/functions/index.js

@@ -0,0 +1,75 @@
+// src/azure/functions/index.mts
+import { createAddHookMessageChannel } from "import-in-the-middle";
+import { register } from "module";
+import { metrics, trace } from "@opentelemetry/api";
+import { registerInstrumentations } from "@opentelemetry/instrumentation";
+
+// src/azure/monitor/start-from-env.ts
+import { useAzureMonitor } from "@azure/monitor-opentelemetry";
+
+// src/azure/monitor/env.ts
+import { createEnv } from "@t3-oss/env-core";
+import { z } from "zod";
+var loadEnv = () => createEnv({
+  emptyStringAsUndefined: true,
+  onValidationError: (errors) => {
+    throw new Error(
+      errors.map(
+        (error) => `Environment variable ${error.path} - ${error.message}`
+      ).join(", ")
+    );
+  },
+  runtimeEnv: process.env,
+  server: {
+    APPINSIGHTS_SAMPLING_PERCENTAGE: z.optional(
+      z.coerce.number().min(0).max(100).default(5).describe(
+        "Application Insights sampling percentage between 0 and 100. If not set, defaults to 5."
+      )
+    ).transform((value) => {
+      const percentage = Number(value);
+      return isNaN(percentage) ? 5 : percentage;
+    }).transform((value) => value / 100),
+    APPLICATIONINSIGHTS_CONNECTION_STRING: z.string().describe("The connection string for Application Insights.")
+  }
+});
+
+// src/azure/monitor/start-from-env.ts
+var initFromEnv = () => {
+  const env = loadEnv();
+  return useAzureMonitor({
+    azureMonitorExporterOptions: {
+      connectionString: env.APPLICATIONINSIGHTS_CONNECTION_STRING
+    },
+    enableLiveMetrics: true,
+    samplingRatio: env.APPINSIGHTS_SAMPLING_PERCENTAGE
+  });
+};
+
+// src/azure/opentelemetry/azure-undici-instrumentation.ts
+import { UndiciInstrumentation } from "@opentelemetry/instrumentation-undici";
+var registerUndiciInstrumentation = () => new UndiciInstrumentation({
+  requestHook: (span, requestInfo) => {
+    const { method, origin, path } = requestInfo;
+    span.setAttributes({
+      "http.host": origin,
+      "http.method": method,
+      "http.target": path,
+      "http.url": `${origin}${path}`
+    });
+  },
+  responseHook: (span, { response }) => {
+    span.setAttribute("http.status_code", response.statusCode);
+  }
+});
+
+// src/azure/functions/index.mts
+var { registerOptions, waitForAllMessagesAcknowledged } = createAddHookMessageChannel();
+register("import-in-the-middle/hook.mjs", import.meta.url, registerOptions);
+initFromEnv();
+registerInstrumentations({
+  instrumentations: [registerUndiciInstrumentation()],
+  meterProvider: metrics.getMeterProvider(),
+  tracerProvider: trace.getTracerProvider()
+});
+await waitForAllMessagesAcknowledged();
+//# sourceMappingURL=index.js.map

package/dist/functions/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/azure/functions/index.mts","../../src/azure/monitor/start-from-env.ts","../../src/azure/monitor/env.ts","../../src/azure/opentelemetry/azure-undici-instrumentation.ts"],"sourcesContent":["/*\nThis file is required to instrument ESM application to use OpenTelemetry.\nThis file must be pre-loaded through the `NODE_OPTIONS` environment variable to\nhave a fully instrumented application.\n */\n\nimport { createAddHookMessageChannel } from \"import-in-the-middle\";\nimport { register } from \"module\";\n\nconst { registerOptions, waitForAllMessagesAcknowledged } =\n  createAddHookMessageChannel();\n\nregister(\"import-in-the-middle/hook.mjs\", import.meta.url, registerOptions);\n\nimport { metrics, trace } from \"@opentelemetry/api\";\nimport { registerInstrumentations } from \"@opentelemetry/instrumentation\";\n\nimport { initFromEnv } from \"../monitor/start-from-env\";\nimport { registerUndiciInstrumentation } from \"../opentelemetry/azure-undici-instrumentation\";\n\ninitFromEnv();\n\nregisterInstrumentations({\n  instrumentations: [registerUndiciInstrumentation()],\n  meterProvider: metrics.getMeterProvider(),\n  tracerProvider: trace.getTracerProvider(),\n});\n\nawait waitForAllMessagesAcknowledged();\n","import { useAzureMonitor } from \"@azure/monitor-opentelemetry\";\n\nimport { loadEnv } from \"./env\";\n\nexport const initFromEnv = () => {\n  const env = loadEnv();\n\n  return useAzureMonitor({\n    azureMonitorExporterOptions: {\n      connectionString: env.APPLICATIONINSIGHTS_CONNECTION_STRING,\n    },\n    enableLiveMetrics: true,\n    samplingRatio: env.APPINSIGHTS_SAMPLING_PERCENTAGE,\n  });\n};\n","// Load and type check environment variables on runtime\nimport { createEnv } from \"@t3-oss/env-core\";\nimport { z } from \"zod\";\n\nexport const loadEnv = () =>\n  createEnv({\n    emptyStringAsUndefined: true,\n    onValidationError: (errors) => {\n      throw new Error(\n        errors\n          .map(\n            (error) => `Environment variable ${error.path} - ${error.message}`,\n          )\n          .join(\", \"),\n      );\n    },\n    runtimeEnv: process.env,\n    server: {\n      APPINSIGHTS_SAMPLING_PERCENTAGE: z\n        .optional(\n          z.coerce\n            .number()\n            .min(0)\n            .max(100)\n            .default(5)\n            .describe(\n              \"Application Insights sampling percentage between 0 and 100. If not set, defaults to 5.\",\n            ),\n        )\n        .transform((value) => {\n          const percentage = Number(value);\n          return isNaN(percentage) ? 5 : percentage;\n        })\n        .transform((value) => value / 100),\n      APPLICATIONINSIGHTS_CONNECTION_STRING: z\n        .string()\n        .describe(\"The connection string for Application Insights.\"),\n    },\n  });\n","import { UndiciInstrumentation } from \"@opentelemetry/instrumentation-undici\";\n\n// instrument native node fetch\nexport const registerUndiciInstrumentation = () =>\n  new UndiciInstrumentation({\n    requestHook: (span, requestInfo) => {\n      const { method, origin, path } = requestInfo;\n      // Default instrumented attributes don't feed well into AppInsights,\n      // so we set them manually.\n      span.setAttributes({\n        \"http.host\": origin,\n        \"http.method\": method,\n        \"http.target\": path,\n        \"http.url\": `${origin}${path}`,\n      });\n    },\n    responseHook: (span, { response }) => {\n      // Same as above, set the status code manually.\n      span.setAttribute(\"http.status_code\", response.statusCode);\n    },\n  });\n"],"mappings":";AAMA,SAAS,mCAAmC;AAC5C,SAAS,gBAAgB;AAOzB,SAAS,SAAS,aAAa;AAC/B,SAAS,gCAAgC;;;ACfzC,SAAS,uBAAuB;;;ACChC,SAAS,iBAAiB;AAC1B,SAAS,SAAS;AAEX,IAAM,UAAU,MACrB,UAAU;AAAA,EACR,wBAAwB;AAAA,EACxB,mBAAmB,CAAC,WAAW;AAC7B,UAAM,IAAI;AAAA,MACR,OACG;AAAA,QACC,CAAC,UAAU,wBAAwB,MAAM,IAAI,MAAM,MAAM,OAAO;AAAA,MAClE,EACC,KAAK,IAAI;AAAA,IACd;AAAA,EACF;AAAA,EACA,YAAY,QAAQ;AAAA,EACpB,QAAQ;AAAA,IACN,iCAAiC,EAC9B;AAAA,MACC,EAAE,OACC,OAAO,EACP,IAAI,CAAC,EACL,IAAI,GAAG,EACP,QAAQ,CAAC,EACT;AAAA,QACC;AAAA,MACF;AAAA,IACJ,EACC,UAAU,CAAC,UAAU;AACpB,YAAM,aAAa,OAAO,KAAK;AAC/B,aAAO,MAAM,UAAU,IAAI,IAAI;AAAA,IACjC,CAAC,EACA,UAAU,CAAC,UAAU,QAAQ,GAAG;AAAA,IACnC,uCAAuC,EACpC,OAAO,EACP,SAAS,iDAAiD;AAAA,EAC/D;AACF,CAAC;;;ADlCI,IAAM,cAAc,MAAM;AAC/B,QAAM,MAAM,QAAQ;AAEpB,SAAO,gBAAgB;AAAA,IACrB,6BAA6B;AAAA,MAC3B,kBAAkB,IAAI;AAAA,IACxB;AAAA,IACA,mBAAmB;AAAA,IACnB,eAAe,IAAI;AAAA,EACrB,CAAC;AACH;;;AEdA,SAAS,6BAA6B;AAG/B,IAAM,gCAAgC,MAC3C,IAAI,sBAAsB;AAAA,EACxB,aAAa,CAAC,MAAM,gBAAgB;AAClC,UAAM,EAAE,QAAQ,QAAQ,KAAK,IAAI;AAGjC,SAAK,cAAc;AAAA,MACjB,aAAa;AAAA,MACb,eAAe;AAAA,MACf,eAAe;AAAA,MACf,YAAY,GAAG,MAAM,GAAG,IAAI;AAAA,IAC9B,CAAC;AAAA,EACH;AAAA,EACA,cAAc,CAAC,MAAM,EAAE,SAAS,MAAM;AAEpC,SAAK,aAAa,oBAAoB,SAAS,UAAU;AAAA,EAC3D;AACF,CAAC;;;AHXH,IAAM,EAAE,iBAAiB,+BAA+B,IACtD,4BAA4B;AAE9B,SAAS,iCAAiC,YAAY,KAAK,eAAe;AAQ1E,YAAY;AAEZ,yBAAyB;AAAA,EACvB,kBAAkB,CAAC,8BAA8B,CAAC;AAAA,EAClD,eAAe,QAAQ,iBAAiB;AAAA,EACxC,gBAAgB,MAAM,kBAAkB;AAC1C,CAAC;AAED,MAAM,+BAA+B;","names":[]}

package/dist/functions/v3/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Interface representing the necessary parts of the Azure Functions v3 Context
+ * for OpenTelemetry trace context propagation.
+ */
+interface FunctionContextV3 {
+    traceContext?: {
+        traceparent?: null | string;
+        tracestate?: null | string;
+    };
+}
+/**
+ * Wraps an Azure Function v3 handler to propagate OpenTelemetry context.
+ *
+ * This function extracts trace context from a v3-like context object (simulated via `FunctionContextV3` interface)
+ * and runs the provided `v3Function` within that context, ensuring OpenTelemetry trace propagation.
+ *
+ * @param context The Azure Function v3 context object (or an object conforming to `FunctionContextV3`).
+ * @param v3Function The original Azure Function v3 handler function.
+ * @returns A new function that, when called with the v3 context, executes the original handler with OpenTelemetry context propagation.
+ */
+declare const withOtelContextFunctionV3: <T extends FunctionContextV3>(context: T) => (v3Function: (context: T) => void) => void;
+
+export { withOtelContextFunctionV3 };

package/dist/functions/v3/index.js

@@ -0,0 +1,15 @@
+// src/azure/functions/v3/index.ts
+import { context as otelContext, propagation } from "@opentelemetry/api";
+var withOtelContextFunctionV3 = (context) => (v3Function) => {
+  const traceContext = context.traceContext ?? {};
+  const headers = {
+    traceparent: traceContext.traceparent,
+    tracestate: traceContext.tracestate
+  };
+  const ctx = propagation.extract(otelContext.active(), headers);
+  return otelContext.with(ctx, () => v3Function(context));
+};
+export {
+  withOtelContextFunctionV3
+};
+//# sourceMappingURL=index.js.map

package/dist/functions/v3/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/azure/functions/v3/index.ts"],"sourcesContent":["import { context as otelContext, propagation } from \"@opentelemetry/api\";\n\n/**\n * Interface representing the necessary parts of the Azure Functions v3 Context\n * for OpenTelemetry trace context propagation.\n */\ninterface FunctionContextV3 {\n  traceContext?: {\n    traceparent?: null | string;\n    tracestate?: null | string;\n  };\n}\n\n/**\n * Wraps an Azure Function v3 handler to propagate OpenTelemetry context.\n *\n * This function extracts trace context from a v3-like context object (simulated via `FunctionContextV3` interface)\n * and runs the provided `v3Function` within that context, ensuring OpenTelemetry trace propagation.\n *\n * @param context The Azure Function v3 context object (or an object conforming to `FunctionContextV3`).\n * @param v3Function The original Azure Function v3 handler function.\n * @returns A new function that, when called with the v3 context, executes the original handler with OpenTelemetry context propagation.\n */\nexport const withOtelContextFunctionV3 =\n  <T extends FunctionContextV3>(context: T) =>\n  (v3Function: (context: T) => void) => {\n    const traceContext = context.traceContext ?? {};\n    const headers = {\n      traceparent: traceContext.traceparent,\n      tracestate: traceContext.tracestate,\n    };\n\n    const ctx = propagation.extract(otelContext.active(), headers);\n    return otelContext.with(ctx, () => v3Function(context));\n  };\n"],"mappings":";AAAA,SAAS,WAAW,aAAa,mBAAmB;AAuB7C,IAAM,4BACX,CAA8B,YAC9B,CAAC,eAAqC;AACpC,QAAM,eAAe,QAAQ,gBAAgB,CAAC;AAC9C,QAAM,UAAU;AAAA,IACd,aAAa,aAAa;AAAA,IAC1B,YAAY,aAAa;AAAA,EAC3B;AAEA,QAAM,MAAM,YAAY,QAAQ,YAAY,OAAO,GAAG,OAAO;AAC7D,SAAO,YAAY,KAAK,KAAK,MAAM,WAAW,OAAO,CAAC;AACxD;","names":[]}

package/dist/monitor/index.d.ts

@@ -0,0 +1,47 @@
+import { AzureMonitorOpenTelemetryOptions } from '@azure/monitor-opentelemetry';
+import { Instrumentation } from '@opentelemetry/instrumentation';
+
+/**
+ * Initialize the Azure Monitor with the given instrumentations and options.
+ * This function sets up telemetry collection for your application by registering
+ * the provided instrumentations and configuring Azure Monitor OpenTelemetry.
+ *
+ * By default, the Undici instrumentation is included. You can extend the functionality
+ * by passing additional instrumentations as an array.
+ *
+ * @remarks
+ * - This function should be called at the start of your application to ensure
+ *   telemetry is collected from the beginning.
+ * - If `azureMonitorOptions` is not provided, the configuration will be initialized
+ *   using environment variables. @see README for more details.
+ *
+ * @example
+ * // Basic usage with default settings
+ * import { initAzureMonitor } from "@pagopa/azure-tracing/azure-monitor";
+ * initAzureMonitor();
+ *
+ * @example
+ * // Usage with custom instrumentations
+ * import { initAzureMonitor } from "@pagopa/azure-tracing/azure-monitor";
+ * import { MyCustomInstrumentation } from "my-custom-instrumentation";
+ *
+ * initAzureMonitor([new MyCustomInstrumentation()]);
+ *
+ * @example
+ * // Usage with custom Azure Monitor options
+ * import { initAzureMonitor } from "@pagopa/azure-tracing/azure-monitor";
+ *
+ * initAzureMonitor([], {
+ *   azureMonitorExporterOptions: {
+ *    connectionString: "theConnectionString",
+ *   },
+ *   // other options...
+ * });
+ *
+ * @param instrumentations - The list of instrumentations to register with the Azure Monitor.
+ * @param azureMonitorOptions - Custom configuration for Azure Monitor. If not provided,
+ *   it will be initialized using environment variables.
+ */
+declare const initAzureMonitor: (instrumentations?: readonly Instrumentation[], azureMonitorOptions?: AzureMonitorOpenTelemetryOptions) => void;
+
+export { initAzureMonitor };

package/dist/monitor/index.js

@@ -0,0 +1,84 @@
+// src/azure/monitor/index.ts
+import {
+  useAzureMonitor as useAzureMonitor2
+} from "@azure/monitor-opentelemetry";
+import { metrics, trace } from "@opentelemetry/api";
+import {
+  registerInstrumentations
+} from "@opentelemetry/instrumentation";
+
+// src/azure/opentelemetry/azure-undici-instrumentation.ts
+import { UndiciInstrumentation } from "@opentelemetry/instrumentation-undici";
+var registerUndiciInstrumentation = () => new UndiciInstrumentation({
+  requestHook: (span, requestInfo) => {
+    const { method, origin, path } = requestInfo;
+    span.setAttributes({
+      "http.host": origin,
+      "http.method": method,
+      "http.target": path,
+      "http.url": `${origin}${path}`
+    });
+  },
+  responseHook: (span, { response }) => {
+    span.setAttribute("http.status_code", response.statusCode);
+  }
+});
+
+// src/azure/monitor/start-from-env.ts
+import { useAzureMonitor } from "@azure/monitor-opentelemetry";
+
+// src/azure/monitor/env.ts
+import { createEnv } from "@t3-oss/env-core";
+import { z } from "zod";
+var loadEnv = () => createEnv({
+  emptyStringAsUndefined: true,
+  onValidationError: (errors) => {
+    throw new Error(
+      errors.map(
+        (error) => `Environment variable ${error.path} - ${error.message}`
+      ).join(", ")
+    );
+  },
+  runtimeEnv: process.env,
+  server: {
+    APPINSIGHTS_SAMPLING_PERCENTAGE: z.optional(
+      z.coerce.number().min(0).max(100).default(5).describe(
+        "Application Insights sampling percentage between 0 and 100. If not set, defaults to 5."
+      )
+    ).transform((value) => {
+      const percentage = Number(value);
+      return isNaN(percentage) ? 5 : percentage;
+    }).transform((value) => value / 100),
+    APPLICATIONINSIGHTS_CONNECTION_STRING: z.string().describe("The connection string for Application Insights.")
+  }
+});
+
+// src/azure/monitor/start-from-env.ts
+var initFromEnv = () => {
+  const env = loadEnv();
+  return useAzureMonitor({
+    azureMonitorExporterOptions: {
+      connectionString: env.APPLICATIONINSIGHTS_CONNECTION_STRING
+    },
+    enableLiveMetrics: true,
+    samplingRatio: env.APPINSIGHTS_SAMPLING_PERCENTAGE
+  });
+};
+
+// src/azure/monitor/index.ts
+var initAzureMonitor = (instrumentations = [], azureMonitorOptions) => {
+  if (azureMonitorOptions) {
+    useAzureMonitor2(azureMonitorOptions);
+  } else {
+    initFromEnv();
+  }
+  registerInstrumentations({
+    instrumentations: [registerUndiciInstrumentation(), ...instrumentations],
+    meterProvider: metrics.getMeterProvider(),
+    tracerProvider: trace.getTracerProvider()
+  });
+};
+export {
+  initAzureMonitor
+};
+//# sourceMappingURL=index.js.map

package/dist/monitor/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/azure/monitor/index.ts","../../src/azure/opentelemetry/azure-undici-instrumentation.ts","../../src/azure/monitor/start-from-env.ts","../../src/azure/monitor/env.ts"],"sourcesContent":["import {\n  AzureMonitorOpenTelemetryOptions,\n  useAzureMonitor,\n} from \"@azure/monitor-opentelemetry\";\nimport { metrics, trace } from \"@opentelemetry/api\";\nimport {\n  Instrumentation,\n  registerInstrumentations,\n} from \"@opentelemetry/instrumentation\";\n\nimport { registerUndiciInstrumentation } from \"../opentelemetry/azure-undici-instrumentation\";\nimport { initFromEnv } from \"./start-from-env\";\n\n/**\n * Initialize the Azure Monitor with the given instrumentations and options.\n * This function sets up telemetry collection for your application by registering\n * the provided instrumentations and configuring Azure Monitor OpenTelemetry.\n *\n * By default, the Undici instrumentation is included. You can extend the functionality\n * by passing additional instrumentations as an array.\n *\n * @remarks\n * - This function should be called at the start of your application to ensure\n *   telemetry is collected from the beginning.\n * - If `azureMonitorOptions` is not provided, the configuration will be initialized\n *   using environment variables. @see README for more details.\n *\n * @example\n * // Basic usage with default settings\n * import { initAzureMonitor } from \"@pagopa/azure-tracing/azure-monitor\";\n * initAzureMonitor();\n *\n * @example\n * // Usage with custom instrumentations\n * import { initAzureMonitor } from \"@pagopa/azure-tracing/azure-monitor\";\n * import { MyCustomInstrumentation } from \"my-custom-instrumentation\";\n *\n * initAzureMonitor([new MyCustomInstrumentation()]);\n *\n * @example\n * // Usage with custom Azure Monitor options\n * import { initAzureMonitor } from \"@pagopa/azure-tracing/azure-monitor\";\n *\n * initAzureMonitor([], {\n *   azureMonitorExporterOptions: {\n *    connectionString: \"theConnectionString\",\n *   },\n *   // other options...\n * });\n *\n * @param instrumentations - The list of instrumentations to register with the Azure Monitor.\n * @param azureMonitorOptions - Custom configuration for Azure Monitor. If not provided,\n *   it will be initialized using environment variables.\n */\nexport const initAzureMonitor = (\n  instrumentations: readonly Instrumentation[] = [],\n  azureMonitorOptions?: AzureMonitorOpenTelemetryOptions,\n) => {\n  if (azureMonitorOptions) {\n    useAzureMonitor(azureMonitorOptions);\n  } else {\n    initFromEnv();\n  }\n\n  registerInstrumentations({\n    instrumentations: [registerUndiciInstrumentation(), ...instrumentations],\n    meterProvider: metrics.getMeterProvider(),\n    tracerProvider: trace.getTracerProvider(),\n  });\n};\n","import { UndiciInstrumentation } from \"@opentelemetry/instrumentation-undici\";\n\n// instrument native node fetch\nexport const registerUndiciInstrumentation = () =>\n  new UndiciInstrumentation({\n    requestHook: (span, requestInfo) => {\n      const { method, origin, path } = requestInfo;\n      // Default instrumented attributes don't feed well into AppInsights,\n      // so we set them manually.\n      span.setAttributes({\n        \"http.host\": origin,\n        \"http.method\": method,\n        \"http.target\": path,\n        \"http.url\": `${origin}${path}`,\n      });\n    },\n    responseHook: (span, { response }) => {\n      // Same as above, set the status code manually.\n      span.setAttribute(\"http.status_code\", response.statusCode);\n    },\n  });\n","import { useAzureMonitor } from \"@azure/monitor-opentelemetry\";\n\nimport { loadEnv } from \"./env\";\n\nexport const initFromEnv = () => {\n  const env = loadEnv();\n\n  return useAzureMonitor({\n    azureMonitorExporterOptions: {\n      connectionString: env.APPLICATIONINSIGHTS_CONNECTION_STRING,\n    },\n    enableLiveMetrics: true,\n    samplingRatio: env.APPINSIGHTS_SAMPLING_PERCENTAGE,\n  });\n};\n","// Load and type check environment variables on runtime\nimport { createEnv } from \"@t3-oss/env-core\";\nimport { z } from \"zod\";\n\nexport const loadEnv = () =>\n  createEnv({\n    emptyStringAsUndefined: true,\n    onValidationError: (errors) => {\n      throw new Error(\n        errors\n          .map(\n            (error) => `Environment variable ${error.path} - ${error.message}`,\n          )\n          .join(\", \"),\n      );\n    },\n    runtimeEnv: process.env,\n    server: {\n      APPINSIGHTS_SAMPLING_PERCENTAGE: z\n        .optional(\n          z.coerce\n            .number()\n            .min(0)\n            .max(100)\n            .default(5)\n            .describe(\n              \"Application Insights sampling percentage between 0 and 100. If not set, defaults to 5.\",\n            ),\n        )\n        .transform((value) => {\n          const percentage = Number(value);\n          return isNaN(percentage) ? 5 : percentage;\n        })\n        .transform((value) => value / 100),\n      APPLICATIONINSIGHTS_CONNECTION_STRING: z\n        .string()\n        .describe(\"The connection string for Application Insights.\"),\n    },\n  });\n"],"mappings":";AAAA;AAAA,EAEE,mBAAAA;AAAA,OACK;AACP,SAAS,SAAS,aAAa;AAC/B;AAAA,EAEE;AAAA,OACK;;;ACRP,SAAS,6BAA6B;AAG/B,IAAM,gCAAgC,MAC3C,IAAI,sBAAsB;AAAA,EACxB,aAAa,CAAC,MAAM,gBAAgB;AAClC,UAAM,EAAE,QAAQ,QAAQ,KAAK,IAAI;AAGjC,SAAK,cAAc;AAAA,MACjB,aAAa;AAAA,MACb,eAAe;AAAA,MACf,eAAe;AAAA,MACf,YAAY,GAAG,MAAM,GAAG,IAAI;AAAA,IAC9B,CAAC;AAAA,EACH;AAAA,EACA,cAAc,CAAC,MAAM,EAAE,SAAS,MAAM;AAEpC,SAAK,aAAa,oBAAoB,SAAS,UAAU;AAAA,EAC3D;AACF,CAAC;;;ACpBH,SAAS,uBAAuB;;;ACChC,SAAS,iBAAiB;AAC1B,SAAS,SAAS;AAEX,IAAM,UAAU,MACrB,UAAU;AAAA,EACR,wBAAwB;AAAA,EACxB,mBAAmB,CAAC,WAAW;AAC7B,UAAM,IAAI;AAAA,MACR,OACG;AAAA,QACC,CAAC,UAAU,wBAAwB,MAAM,IAAI,MAAM,MAAM,OAAO;AAAA,MAClE,EACC,KAAK,IAAI;AAAA,IACd;AAAA,EACF;AAAA,EACA,YAAY,QAAQ;AAAA,EACpB,QAAQ;AAAA,IACN,iCAAiC,EAC9B;AAAA,MACC,EAAE,OACC,OAAO,EACP,IAAI,CAAC,EACL,IAAI,GAAG,EACP,QAAQ,CAAC,EACT;AAAA,QACC;AAAA,MACF;AAAA,IACJ,EACC,UAAU,CAAC,UAAU;AACpB,YAAM,aAAa,OAAO,KAAK;AAC/B,aAAO,MAAM,UAAU,IAAI,IAAI;AAAA,IACjC,CAAC,EACA,UAAU,CAAC,UAAU,QAAQ,GAAG;AAAA,IACnC,uCAAuC,EACpC,OAAO,EACP,SAAS,iDAAiD;AAAA,EAC/D;AACF,CAAC;;;ADlCI,IAAM,cAAc,MAAM;AAC/B,QAAM,MAAM,QAAQ;AAEpB,SAAO,gBAAgB;AAAA,IACrB,6BAA6B;AAAA,MAC3B,kBAAkB,IAAI;AAAA,IACxB;AAAA,IACA,mBAAmB;AAAA,IACnB,eAAe,IAAI;AAAA,EACrB,CAAC;AACH;;;AFwCO,IAAM,mBAAmB,CAC9B,mBAA+C,CAAC,GAChD,wBACG;AACH,MAAI,qBAAqB;AACvB,IAAAC,iBAAgB,mBAAmB;AAAA,EACrC,OAAO;AACL,gBAAY;AAAA,EACd;AAEA,2BAAyB;AAAA,IACvB,kBAAkB,CAAC,8BAA8B,GAAG,GAAG,gBAAgB;AAAA,IACvE,eAAe,QAAQ,iBAAiB;AAAA,IACxC,gBAAgB,MAAM,kBAAkB;AAAA,EAC1C,CAAC;AACH;","names":["useAzureMonitor","useAzureMonitor"]}

package/dist/opentelemetry/logger.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Emit a custom event to the Azure Monitor.
+ * This function is used to emit custom events to the Azure Monitor.
+ *
+ * @param eventName the name of the event to emit
+ * @param attributes the attributes to include with the event
+ */
+declare const emitCustomEvent: (eventName: string, attributes?: Record<string, string>) => (loggerName?: string) => void;
+
+export { emitCustomEvent };

package/dist/opentelemetry/logger.js

@@ -0,0 +1,14 @@
+// src/azure/opentelemetry/logger.ts
+import { logs } from "@opentelemetry/api-logs";
+var emitCustomEvent = (eventName, attributes = {}) => (loggerName = "ApplicationInsightsLogger") => {
+  logs.getLogger(loggerName).emit({
+    attributes: {
+      "microsoft.custom_event.name": eventName,
+      ...attributes
+    }
+  });
+};
+export {
+  emitCustomEvent
+};
+//# sourceMappingURL=logger.js.map

package/dist/opentelemetry/logger.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/azure/opentelemetry/logger.ts"],"sourcesContent":["import { logs } from \"@opentelemetry/api-logs\";\n\n/**\n * Emit a custom event to the Azure Monitor.\n * This function is used to emit custom events to the Azure Monitor.\n *\n * @param eventName the name of the event to emit\n * @param attributes the attributes to include with the event\n */\nexport const emitCustomEvent =\n  (eventName: string, attributes: Record<string, string> = {}) =>\n  (loggerName = \"ApplicationInsightsLogger\") => {\n    logs.getLogger(loggerName).emit({\n      attributes: {\n        \"microsoft.custom_event.name\": eventName,\n        ...attributes,\n      },\n    });\n  };\n"],"mappings":";AAAA,SAAS,YAAY;AASd,IAAM,kBACX,CAAC,WAAmB,aAAqC,CAAC,MAC1D,CAAC,aAAa,gCAAgC;AAC5C,OAAK,UAAU,UAAU,EAAE,KAAK;AAAA,IAC9B,YAAY;AAAA,MACV,+BAA+B;AAAA,MAC/B,GAAG;AAAA,IACL;AAAA,EACF,CAAC;AACH;","names":[]}

package/package.json

@@ -1,8 +1,13 @@
 {
   "name": "@pagopa/azure-tracing",
-  "version": "0.4.1-beta.0",
+  "version": "0.4.2",
   "type": "module",
   "description": "A package that contains some utilities to enable Azure tracing on Node.js applications.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pagopa/dx.git",
+    "directory": "packages/azure-tracing"
+  },
   "keywords": [
     "azure",
     "azuremonitor",
@@ -34,12 +39,12 @@
     "@azure/monitor-opentelemetry": "^1.11.0",
     "@azure/monitor-opentelemetry-exporter": "^1.0.0-beta.31",
     "@opentelemetry/api": "^1.9.0",
-    "@opentelemetry/api-logs": "^0.202.0",
-    "@opentelemetry/instrumentation": "^0.202.0",
-    "@opentelemetry/instrumentation-undici": "^0.13.0",
-    "@t3-oss/env-core": "^0.13.6",
-    "import-in-the-middle": "^1.14.0",
-    "zod": "^3.25.49"
+    "@opentelemetry/api-logs": "^0.201.1",
+    "@opentelemetry/instrumentation": "^0.201.1",
+    "@opentelemetry/instrumentation-undici": "^0.12.0",
+    "@t3-oss/env-core": "^0.13.4",
+    "import-in-the-middle": "^1.13.2",
+    "zod": "^3.25.28"
   },
   "devDependencies": {
     "@pagopa/eslint-config": "workspace:^",