@pingops/sdk 0.1.2 → 0.1.3

package/README.md

@@ -10,16 +10,52 @@ pnpm add @pingops/sdk
 
 ## Quick Start
 
+### Option 1: Auto-initialization (Recommended)
+
+**Most automatic approach** - Use Node.js `--require` flag (runs before any imports):
+
+```bash
+node --require @pingops/sdk/register your-app.js
+```
+
+Set environment variables:
+
+```bash
+export PINGOPS_API_KEY="your-api-key"
+export PINGOPS_BASE_URL="https://api.pingops.com"
+export PINGOPS_SERVICE_NAME="my-service"
+```
+
+**Or** import the register file FIRST in your code:
+
+```typescript
+// Import this FIRST, before any HTTP clients
+import "@pingops/sdk/register";
+
+import axios from "axios";
+// ... rest of your code
+```
+
+### Option 2: Manual initialization
+
 ```typescript
 import { initializePingops } from "@pingops/sdk";
 
+// Option A: pass a config object directly
 initializePingops({
   apiKey: "your-api-key", // or set PINGOPS_API_KEY env var
   baseUrl: "https://api.pingops.com",
   serviceName: "my-service",
 });
+
+// Option B: pass a JSON/YAML config file path (env vars override file values)
+initializePingops("./pingops.config.yaml");
+// or:
+initializePingops({ configFile: "./pingops.config.json" });
 ```
 
+**Important**: If using manual initialization, call `initializePingops()` before importing any HTTP clients (axios, fetch, etc.) to ensure proper instrumentation.
+
 ## Features
 
 - **Automatic Instrumentation**: Captures HTTP and fetch API calls automatically

package/dist/index.cjs

@@ -1,248 +1,5 @@
-let _opentelemetry_sdk_node = require("@opentelemetry/sdk-node");
-let _opentelemetry_resources = require("@opentelemetry/resources");
-let _opentelemetry_semantic_conventions = require("@opentelemetry/semantic-conventions");
-let _opentelemetry_sdk_trace_node = require("@opentelemetry/sdk-trace-node");
-let _pingops_otel = require("@pingops/otel");
-let _pingops_core = require("@pingops/core");
+const require_pingops = require('./pingops-Cb6UV5D8.cjs');
 
-//#region src/init-state.ts
-/**
-* Shared state for tracking SDK initialization
-* This module exists to avoid circular dependencies between pingops.ts and instrumentation.ts
-*/
-let isSdkInitializedFlag$1 = false;
-/**
-* Sets the SDK initialization flag.
-* Called by initializePingops when the SDK is initialized.
-*/
-function setSdkInitialized(initialized) {
-	isSdkInitializedFlag$1 = initialized;
-}
-/**
-* Checks if global instrumentation is enabled.
-* This is used to determine instrumentation behavior:
-* - If true: all HTTP requests are instrumented
-* - If false: only requests within wrapHttp blocks are instrumented
-*/
-function isGlobalInstrumentationEnabled() {
-	return isSdkInitializedFlag$1;
-}
-
-//#endregion
-//#region src/pingops.ts
-/**
-* PingOps SDK singleton for manual instrumentation
-*
-* Provides initializePingops and shutdownPingops functions.
-* wrapHttp is available from @pingops/core and will auto-initialize
-* from environment variables if needed.
-*/
-const initLogger = (0, _pingops_core.createLogger)("[PingOps Initialize]");
-const logger = (0, _pingops_core.createLogger)("[PingOps Pingops]");
-let sdkInstance = null;
-let isSdkInitializedFlag = false;
-/**
-* Global state to track initialization
-*/
-let isInitialized = false;
-let initializationPromise = null;
-/**
-* Initializes PingOps SDK
-*
-* This function:
-* 1. Creates an OpenTelemetry NodeSDK instance
-* 2. Configures Resource with service.name
-* 3. Registers PingopsSpanProcessor
-* 4. Enables HTTP/fetch/GenAI instrumentation
-* 5. Starts the SDK
-*
-* @param config - Configuration for the SDK
-* @param explicit - Whether this is an explicit call (default: true).
-*                   Set to false when called internally by wrapHttp auto-initialization.
-*/
-function initializePingops(config, explicit = true) {
-	if (isSdkInitializedFlag) {
-		if (config.debug) initLogger.warn("[PingOps] SDK already initialized, skipping");
-		return;
-	}
-	const resource = (0, _opentelemetry_resources.resourceFromAttributes)({ [_opentelemetry_semantic_conventions.ATTR_SERVICE_NAME]: config.serviceName });
-	const processor = new _pingops_otel.PingopsSpanProcessor(config);
-	const instrumentations = (0, _pingops_otel.getInstrumentations)(isGlobalInstrumentationEnabled);
-	const nodeSdk = new _opentelemetry_sdk_node.NodeSDK({
-		resource,
-		spanProcessors: [processor],
-		instrumentations
-	});
-	nodeSdk.start();
-	sdkInstance = nodeSdk;
-	isSdkInitializedFlag = true;
-	setSdkInitialized(explicit);
-	try {
-		const isolatedProvider = new _opentelemetry_sdk_trace_node.NodeTracerProvider({
-			resource,
-			spanProcessors: [processor]
-		});
-		isolatedProvider.register();
-		(0, _pingops_otel.setPingopsTracerProvider)(isolatedProvider);
-	} catch (error) {
-		if (config.debug) initLogger.error("[PingOps] Failed to create isolated TracerProvider:", error instanceof Error ? error.message : String(error));
-	}
-	if (config.debug) initLogger.info("[PingOps] SDK initialized");
-}
-/**
-* Shuts down the SDK and flushes remaining spans
-*/
-async function shutdownPingops() {
-	await (0, _pingops_otel.shutdownTracerProvider)();
-	if (!sdkInstance) return;
-	await sdkInstance.shutdown();
-	sdkInstance = null;
-	isSdkInitializedFlag = false;
-	setSdkInitialized(false);
-}
-/**
-* Checks if the SDK is already initialized by checking if a NodeTracerProvider is available
-*/
-function isSdkInitialized() {
-	try {
-		const provider = (0, _pingops_otel.getPingopsTracerProvider)();
-		const initialized = provider instanceof _opentelemetry_sdk_trace_node.NodeTracerProvider;
-		logger.debug("Checked SDK initialization status", {
-			initialized,
-			providerType: provider.constructor.name
-		});
-		return initialized;
-	} catch (error) {
-		logger.debug("Error checking SDK initialization status", { error: error instanceof Error ? error.message : String(error) });
-		return false;
-	}
-}
-/**
-* Auto-initializes the SDK from environment variables if not already initialized
-*/
-async function ensureInitialized() {
-	if (isSdkInitialized()) {
-		logger.debug("SDK already initialized, skipping auto-initialization");
-		isInitialized = true;
-		return;
-	}
-	if (isInitialized) {
-		logger.debug("SDK initialization flag already set, skipping");
-		return;
-	}
-	if (initializationPromise) {
-		logger.debug("SDK initialization already in progress, waiting...");
-		return initializationPromise;
-	}
-	logger.info("Starting SDK auto-initialization from environment variables");
-	initializationPromise = Promise.resolve().then(() => {
-		const apiKey = process.env.PINGOPS_API_KEY;
-		const baseUrl = process.env.PINGOPS_BASE_URL;
-		const serviceName = process.env.PINGOPS_SERVICE_NAME;
-		const debug = process.env.PINGOPS_DEBUG === "true";
-		logger.debug("Reading environment variables", {
-			hasApiKey: !!apiKey,
-			hasBaseUrl: !!baseUrl,
-			hasServiceName: !!serviceName,
-			debug
-		});
-		if (!apiKey || !baseUrl || !serviceName) {
-			const missing = [
-				!apiKey && "PINGOPS_API_KEY",
-				!baseUrl && "PINGOPS_BASE_URL",
-				!serviceName && "PINGOPS_SERVICE_NAME"
-			].filter(Boolean);
-			logger.error("Missing required environment variables for auto-initialization", { missing });
-			throw new Error(`PingOps SDK auto-initialization requires PINGOPS_API_KEY, PINGOPS_BASE_URL, and PINGOPS_SERVICE_NAME environment variables. Missing: ${missing.join(", ")}`);
-		}
-		const config = {
-			apiKey,
-			baseUrl,
-			serviceName,
-			debug
-		};
-		logger.info("Initializing SDK with config", {
-			baseUrl,
-			serviceName,
-			debug
-		});
-		initializePingops(config, false);
-		isInitialized = true;
-		logger.info("SDK auto-initialization completed successfully");
-	});
-	try {
-		await initializationPromise;
-	} catch (error) {
-		logger.error("SDK auto-initialization failed", { error: error instanceof Error ? error.message : String(error) });
-		throw error;
-	} finally {
-		initializationPromise = null;
-	}
-}
-/**
-* Wraps a function to set attributes on HTTP spans created within the wrapped block.
-*
-* This function sets attributes (userId, sessionId, tags, metadata) in the OpenTelemetry
-* context, which are automatically propagated to all spans created within the wrapped function.
-*
-* Instrumentation behavior:
-* - If `initializePingops` was called: All HTTP requests are instrumented by default.
-*   `wrapHttp` only adds attributes to spans created within the wrapped block.
-* - If `initializePingops` was NOT called: Only HTTP requests within `wrapHttp` blocks
-*   are instrumented. Requests outside `wrapHttp` are not instrumented.
-*
-* @param options - Options including attributes to propagate to spans
-* @param fn - Function to execute within the attribute context
-* @returns The result of the function
-*
-* @example
-* ```typescript
-* import { wrapHttp } from '@pingops/sdk';
-*
-* // Scenario 1: initializePingops was called
-* initializePingops({ ... });
-*
-* // All HTTP requests are instrumented, but this block adds attributes
-* const result = await wrapHttp({
-*   attributes: {
-*     userId: 'user-123',
-*     sessionId: 'session-456',
-*     tags: ['production', 'api'],
-*     metadata: { environment: 'prod', version: '1.0.0' }
-*   }
-* }, async () => {
-*   // This HTTP request will be instrumented AND have the attributes set above
-*   const response = await fetch('https://api.example.com/users/123');
-*   return response.json();
-* });
-*
-* // HTTP requests outside wrapHttp are still instrumented, just without the attributes
-* const otherResponse = await fetch('https://api.example.com/other');
-*
-* // Scenario 2: initializePingops was NOT called
-* // Only requests within wrapHttp are instrumented
-* await wrapHttp({
-*   attributes: { userId: 'user-123' }
-* }, async () => {
-*   // This request IS instrumented
-*   return fetch('https://api.example.com/data');
-* });
-*
-* // This request is NOT instrumented (outside wrapHttp)
-* await fetch('https://api.example.com/other');
-* ```
-*/
-function wrapHttp(options, fn) {
-	return (0, _pingops_core.wrapHttp)({
-		...options,
-		checkInitialized: isSdkInitialized,
-		isGlobalInstrumentationEnabled,
-		ensureInitialized
-	}, fn);
-}
-
-//#endregion
-exports.initializePingops = initializePingops;
-exports.shutdownPingops = shutdownPingops;
-exports.wrapHttp = wrapHttp;
-//# sourceMappingURL=index.cjs.map
+exports.initializePingops = require_pingops.initializePingops;
+exports.shutdownPingops = require_pingops.shutdownPingops;
+exports.wrapHttp = require_pingops.wrapHttp;

package/dist/index.d.cts

@@ -13,11 +13,15 @@ import { WrapHttpAttributes, WrapHttpAttributes as WrapHttpAttributes$1 } from "
  * 4. Enables HTTP/fetch/GenAI instrumentation
  * 5. Starts the SDK
  *
- * @param config - Configuration for the SDK
+ * @param config - Configuration object, config file path, or config file wrapper
  * @param explicit - Whether this is an explicit call (default: true).
  *                   Set to false when called internally by wrapHttp auto-initialization.
  */
 declare function initializePingops(config: PingopsProcessorConfig, explicit?: boolean): void;
+declare function initializePingops(configFilePath: string, explicit?: boolean): void;
+declare function initializePingops(config: {
+  configFile: string;
+}, explicit?: boolean): void;
 /**
  * Shuts down the SDK and flushes remaining spans
  */

package/dist/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../src/pingops.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;;iBAwDgB,iBAAA,SACN;;;;iBAoEY,eAAA,CAAA,GAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgLzB;eACU;aACd,IAAI,QAAQ,KACrB,IAAI,QAAQ"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/pingops.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;;iBAyDgB,iBAAA,SACN;iBAGM,iBAAA;iBAIA,iBAAA;;;;;;iBAwGM,eAAA,CAAA,GAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgLzB;eACU;aACd,IAAI,QAAQ,KACrB,IAAI,QAAQ"}

package/dist/index.d.mts

@@ -13,11 +13,15 @@ import { WrapHttpAttributes, WrapHttpAttributes as WrapHttpAttributes$1 } from "
  * 4. Enables HTTP/fetch/GenAI instrumentation
  * 5. Starts the SDK
  *
- * @param config - Configuration for the SDK
+ * @param config - Configuration object, config file path, or config file wrapper
  * @param explicit - Whether this is an explicit call (default: true).
  *                   Set to false when called internally by wrapHttp auto-initialization.
  */
 declare function initializePingops(config: PingopsProcessorConfig, explicit?: boolean): void;
+declare function initializePingops(configFilePath: string, explicit?: boolean): void;
+declare function initializePingops(config: {
+  configFile: string;
+}, explicit?: boolean): void;
 /**
  * Shuts down the SDK and flushes remaining spans
  */

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/pingops.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;;iBAwDgB,iBAAA,SACN;;;;iBAoEY,eAAA,CAAA,GAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgLzB;eACU;aACd,IAAI,QAAQ,KACrB,IAAI,QAAQ"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/pingops.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;;iBAyDgB,iBAAA,SACN;iBAGM,iBAAA;iBAIA,iBAAA;;;;;;iBAwGM,eAAA,CAAA,GAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgLzB;eACU;aACd,IAAI,QAAQ,KACrB,IAAI,QAAQ"}

package/dist/index.mjs

@@ -1,246 +1,3 @@
-import { NodeSDK } from "@opentelemetry/sdk-node";
-import { resourceFromAttributes } from "@opentelemetry/resources";
-import { ATTR_SERVICE_NAME } from "@opentelemetry/semantic-conventions";
-import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
-import { PingopsSpanProcessor, getInstrumentations, getPingopsTracerProvider, setPingopsTracerProvider, shutdownTracerProvider } from "@pingops/otel";
-import { createLogger, wrapHttp as wrapHttp$1 } from "@pingops/core";
+import { n as shutdownPingops, r as wrapHttp, t as initializePingops } from "./pingops-DlQdUQEU.mjs";
 
-//#region src/init-state.ts
-/**
-* Shared state for tracking SDK initialization
-* This module exists to avoid circular dependencies between pingops.ts and instrumentation.ts
-*/
-let isSdkInitializedFlag$1 = false;
-/**
-* Sets the SDK initialization flag.
-* Called by initializePingops when the SDK is initialized.
-*/
-function setSdkInitialized(initialized) {
-	isSdkInitializedFlag$1 = initialized;
-}
-/**
-* Checks if global instrumentation is enabled.
-* This is used to determine instrumentation behavior:
-* - If true: all HTTP requests are instrumented
-* - If false: only requests within wrapHttp blocks are instrumented
-*/
-function isGlobalInstrumentationEnabled() {
-	return isSdkInitializedFlag$1;
-}
-
-//#endregion
-//#region src/pingops.ts
-/**
-* PingOps SDK singleton for manual instrumentation
-*
-* Provides initializePingops and shutdownPingops functions.
-* wrapHttp is available from @pingops/core and will auto-initialize
-* from environment variables if needed.
-*/
-const initLogger = createLogger("[PingOps Initialize]");
-const logger = createLogger("[PingOps Pingops]");
-let sdkInstance = null;
-let isSdkInitializedFlag = false;
-/**
-* Global state to track initialization
-*/
-let isInitialized = false;
-let initializationPromise = null;
-/**
-* Initializes PingOps SDK
-*
-* This function:
-* 1. Creates an OpenTelemetry NodeSDK instance
-* 2. Configures Resource with service.name
-* 3. Registers PingopsSpanProcessor
-* 4. Enables HTTP/fetch/GenAI instrumentation
-* 5. Starts the SDK
-*
-* @param config - Configuration for the SDK
-* @param explicit - Whether this is an explicit call (default: true).
-*                   Set to false when called internally by wrapHttp auto-initialization.
-*/
-function initializePingops(config, explicit = true) {
-	if (isSdkInitializedFlag) {
-		if (config.debug) initLogger.warn("[PingOps] SDK already initialized, skipping");
-		return;
-	}
-	const resource = resourceFromAttributes({ [ATTR_SERVICE_NAME]: config.serviceName });
-	const processor = new PingopsSpanProcessor(config);
-	const instrumentations = getInstrumentations(isGlobalInstrumentationEnabled);
-	const nodeSdk = new NodeSDK({
-		resource,
-		spanProcessors: [processor],
-		instrumentations
-	});
-	nodeSdk.start();
-	sdkInstance = nodeSdk;
-	isSdkInitializedFlag = true;
-	setSdkInitialized(explicit);
-	try {
-		const isolatedProvider = new NodeTracerProvider({
-			resource,
-			spanProcessors: [processor]
-		});
-		isolatedProvider.register();
-		setPingopsTracerProvider(isolatedProvider);
-	} catch (error) {
-		if (config.debug) initLogger.error("[PingOps] Failed to create isolated TracerProvider:", error instanceof Error ? error.message : String(error));
-	}
-	if (config.debug) initLogger.info("[PingOps] SDK initialized");
-}
-/**
-* Shuts down the SDK and flushes remaining spans
-*/
-async function shutdownPingops() {
-	await shutdownTracerProvider();
-	if (!sdkInstance) return;
-	await sdkInstance.shutdown();
-	sdkInstance = null;
-	isSdkInitializedFlag = false;
-	setSdkInitialized(false);
-}
-/**
-* Checks if the SDK is already initialized by checking if a NodeTracerProvider is available
-*/
-function isSdkInitialized() {
-	try {
-		const provider = getPingopsTracerProvider();
-		const initialized = provider instanceof NodeTracerProvider;
-		logger.debug("Checked SDK initialization status", {
-			initialized,
-			providerType: provider.constructor.name
-		});
-		return initialized;
-	} catch (error) {
-		logger.debug("Error checking SDK initialization status", { error: error instanceof Error ? error.message : String(error) });
-		return false;
-	}
-}
-/**
-* Auto-initializes the SDK from environment variables if not already initialized
-*/
-async function ensureInitialized() {
-	if (isSdkInitialized()) {
-		logger.debug("SDK already initialized, skipping auto-initialization");
-		isInitialized = true;
-		return;
-	}
-	if (isInitialized) {
-		logger.debug("SDK initialization flag already set, skipping");
-		return;
-	}
-	if (initializationPromise) {
-		logger.debug("SDK initialization already in progress, waiting...");
-		return initializationPromise;
-	}
-	logger.info("Starting SDK auto-initialization from environment variables");
-	initializationPromise = Promise.resolve().then(() => {
-		const apiKey = process.env.PINGOPS_API_KEY;
-		const baseUrl = process.env.PINGOPS_BASE_URL;
-		const serviceName = process.env.PINGOPS_SERVICE_NAME;
-		const debug = process.env.PINGOPS_DEBUG === "true";
-		logger.debug("Reading environment variables", {
-			hasApiKey: !!apiKey,
-			hasBaseUrl: !!baseUrl,
-			hasServiceName: !!serviceName,
-			debug
-		});
-		if (!apiKey || !baseUrl || !serviceName) {
-			const missing = [
-				!apiKey && "PINGOPS_API_KEY",
-				!baseUrl && "PINGOPS_BASE_URL",
-				!serviceName && "PINGOPS_SERVICE_NAME"
-			].filter(Boolean);
-			logger.error("Missing required environment variables for auto-initialization", { missing });
-			throw new Error(`PingOps SDK auto-initialization requires PINGOPS_API_KEY, PINGOPS_BASE_URL, and PINGOPS_SERVICE_NAME environment variables. Missing: ${missing.join(", ")}`);
-		}
-		const config = {
-			apiKey,
-			baseUrl,
-			serviceName,
-			debug
-		};
-		logger.info("Initializing SDK with config", {
-			baseUrl,
-			serviceName,
-			debug
-		});
-		initializePingops(config, false);
-		isInitialized = true;
-		logger.info("SDK auto-initialization completed successfully");
-	});
-	try {
-		await initializationPromise;
-	} catch (error) {
-		logger.error("SDK auto-initialization failed", { error: error instanceof Error ? error.message : String(error) });
-		throw error;
-	} finally {
-		initializationPromise = null;
-	}
-}
-/**
-* Wraps a function to set attributes on HTTP spans created within the wrapped block.
-*
-* This function sets attributes (userId, sessionId, tags, metadata) in the OpenTelemetry
-* context, which are automatically propagated to all spans created within the wrapped function.
-*
-* Instrumentation behavior:
-* - If `initializePingops` was called: All HTTP requests are instrumented by default.
-*   `wrapHttp` only adds attributes to spans created within the wrapped block.
-* - If `initializePingops` was NOT called: Only HTTP requests within `wrapHttp` blocks
-*   are instrumented. Requests outside `wrapHttp` are not instrumented.
-*
-* @param options - Options including attributes to propagate to spans
-* @param fn - Function to execute within the attribute context
-* @returns The result of the function
-*
-* @example
-* ```typescript
-* import { wrapHttp } from '@pingops/sdk';
-*
-* // Scenario 1: initializePingops was called
-* initializePingops({ ... });
-*
-* // All HTTP requests are instrumented, but this block adds attributes
-* const result = await wrapHttp({
-*   attributes: {
-*     userId: 'user-123',
-*     sessionId: 'session-456',
-*     tags: ['production', 'api'],
-*     metadata: { environment: 'prod', version: '1.0.0' }
-*   }
-* }, async () => {
-*   // This HTTP request will be instrumented AND have the attributes set above
-*   const response = await fetch('https://api.example.com/users/123');
-*   return response.json();
-* });
-*
-* // HTTP requests outside wrapHttp are still instrumented, just without the attributes
-* const otherResponse = await fetch('https://api.example.com/other');
-*
-* // Scenario 2: initializePingops was NOT called
-* // Only requests within wrapHttp are instrumented
-* await wrapHttp({
-*   attributes: { userId: 'user-123' }
-* }, async () => {
-*   // This request IS instrumented
-*   return fetch('https://api.example.com/data');
-* });
-*
-* // This request is NOT instrumented (outside wrapHttp)
-* await fetch('https://api.example.com/other');
-* ```
-*/
-function wrapHttp(options, fn) {
-	return wrapHttp$1({
-		...options,
-		checkInitialized: isSdkInitialized,
-		isGlobalInstrumentationEnabled,
-		ensureInitialized
-	}, fn);
-}
-
-//#endregion
-export { initializePingops, shutdownPingops, wrapHttp };
-//# sourceMappingURL=index.mjs.map
+export { initializePingops, shutdownPingops, wrapHttp };