@pingops/sdk 0.1.0 → 0.1.2

package/dist/index.cjs

@@ -0,0 +1,248 @@
+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");
+
+//#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

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["isSdkInitializedFlag","ATTR_SERVICE_NAME","PingopsSpanProcessor","NodeSDK","NodeTracerProvider"],"sources":["../src/init-state.ts","../src/pingops.ts"],"sourcesContent":["/**\n * Shared state for tracking SDK initialization\n * This module exists to avoid circular dependencies between pingops.ts and instrumentation.ts\n */\n\nlet isSdkInitializedFlag = false;\n\n/**\n * Sets the SDK initialization flag.\n * Called by initializePingops when the SDK is initialized.\n */\nexport function setSdkInitialized(initialized: boolean): void {\n  isSdkInitializedFlag = initialized;\n}\n\n/**\n * Checks if global instrumentation is enabled.\n * This is used to determine instrumentation behavior:\n * - If true: all HTTP requests are instrumented\n * - If false: only requests within wrapHttp blocks are instrumented\n */\nexport function isGlobalInstrumentationEnabled(): boolean {\n  return isSdkInitializedFlag;\n}\n","/**\n * PingOps SDK singleton for manual instrumentation\n *\n * Provides initializePingops and shutdownPingops functions.\n * wrapHttp is available from @pingops/core and will auto-initialize\n * from environment variables if needed.\n */\n\nimport { NodeSDK } from \"@opentelemetry/sdk-node\";\nimport { resourceFromAttributes } from \"@opentelemetry/resources\";\nimport { ATTR_SERVICE_NAME } from \"@opentelemetry/semantic-conventions\";\nimport { NodeTracerProvider } from \"@opentelemetry/sdk-trace-node\";\nimport type { PingopsProcessorConfig } from \"@pingops/otel\";\nimport {\n  setPingopsTracerProvider,\n  shutdownTracerProvider,\n  PingopsSpanProcessor,\n} from \"@pingops/otel\";\nimport { createLogger } from \"@pingops/core\";\nimport {\n  setSdkInitialized,\n  isGlobalInstrumentationEnabled,\n} from \"./init-state\";\nimport {\n  wrapHttp as coreWrapHttp,\n  type WrapHttpAttributes,\n} from \"@pingops/core\";\nimport { getPingopsTracerProvider } from \"@pingops/otel\";\nimport { getInstrumentations } from \"@pingops/otel\";\n\nconst initLogger = createLogger(\"[PingOps Initialize]\");\nconst logger = createLogger(\"[PingOps Pingops]\");\n\nlet sdkInstance: NodeSDK | null = null;\nlet isSdkInitializedFlag = false;\n\n/**\n * Global state to track initialization\n */\nlet isInitialized = false;\nlet initializationPromise: Promise<void> | null = null;\n\n/**\n * Initializes PingOps SDK\n *\n * This function:\n * 1. Creates an OpenTelemetry NodeSDK instance\n * 2. Configures Resource with service.name\n * 3. Registers PingopsSpanProcessor\n * 4. Enables HTTP/fetch/GenAI instrumentation\n * 5. Starts the SDK\n *\n * @param config - Configuration for the SDK\n * @param explicit - Whether this is an explicit call (default: true).\n *                   Set to false when called internally by wrapHttp auto-initialization.\n */\nexport function initializePingops(\n  config: PingopsProcessorConfig,\n  explicit: boolean = true\n): void {\n  if (isSdkInitializedFlag) {\n    if (config.debug) {\n      initLogger.warn(\"[PingOps] SDK already initialized, skipping\");\n    }\n    return;\n  }\n\n  // Create resource with service name\n  const resource = resourceFromAttributes({\n    [ATTR_SERVICE_NAME]: config.serviceName,\n  });\n\n  const processor = new PingopsSpanProcessor(config);\n  const instrumentations = getInstrumentations(isGlobalInstrumentationEnabled);\n\n  // Node.js SDK\n  const nodeSdk = new NodeSDK({\n    resource,\n    spanProcessors: [processor],\n    instrumentations,\n  });\n\n  nodeSdk.start();\n  sdkInstance = nodeSdk;\n\n  // Mark SDK as initialized\n  isSdkInitializedFlag = true;\n\n  // Only enable global instrumentation if this was an explicit call\n  // If called via wrapHttp auto-initialization, global instrumentation stays disabled\n  setSdkInitialized(explicit);\n\n  // Initialize isolated TracerProvider for manual spans AFTER NodeSDK starts\n  // This ensures manual spans created via startSpan are processed by the same processor\n  // We register it after NodeSDK so it takes precedence as the global provider\n  try {\n    // In version 2.2.0, span processors are passed in the constructor\n    const isolatedProvider = new NodeTracerProvider({\n      resource,\n      spanProcessors: [processor],\n    });\n\n    // Register the provider globally\n    isolatedProvider.register();\n\n    // Set it in global state\n    setPingopsTracerProvider(isolatedProvider);\n  } catch (error) {\n    if (config.debug) {\n      initLogger.error(\n        \"[PingOps] Failed to create isolated TracerProvider:\",\n        error instanceof Error ? error.message : String(error)\n      );\n    }\n    // Continue without isolated provider - manual spans will use global provider\n  }\n\n  if (config.debug) {\n    initLogger.info(\"[PingOps] SDK initialized\");\n  }\n}\n\n/**\n * Shuts down the SDK and flushes remaining spans\n */\nexport async function shutdownPingops(): Promise<void> {\n  // Shutdown isolated TracerProvider first\n  await shutdownTracerProvider();\n\n  if (!sdkInstance) {\n    return;\n  }\n\n  await sdkInstance.shutdown();\n  sdkInstance = null;\n  isSdkInitializedFlag = false;\n  setSdkInitialized(false);\n}\n\n/**\n * Checks if the SDK is already initialized by checking if a NodeTracerProvider is available\n */\nfunction isSdkInitialized(): boolean {\n  try {\n    const provider = getPingopsTracerProvider();\n    // If we have a NodeTracerProvider (not the default NoOpTracerProvider), SDK is initialized\n    const initialized = provider instanceof NodeTracerProvider;\n    logger.debug(\"Checked SDK initialization status\", {\n      initialized,\n      providerType: provider.constructor.name,\n    });\n    return initialized;\n  } catch (error) {\n    logger.debug(\"Error checking SDK initialization status\", {\n      error: error instanceof Error ? error.message : String(error),\n    });\n    return false;\n  }\n}\n\n/**\n * Auto-initializes the SDK from environment variables if not already initialized\n */\nasync function ensureInitialized(): Promise<void> {\n  // Check if SDK is already initialized (e.g., by calling initializePingops directly)\n  if (isSdkInitialized()) {\n    logger.debug(\"SDK already initialized, skipping auto-initialization\");\n    isInitialized = true;\n    return;\n  }\n\n  if (isInitialized) {\n    logger.debug(\"SDK initialization flag already set, skipping\");\n    return;\n  }\n\n  // If initialization is in progress, wait for it\n  if (initializationPromise) {\n    logger.debug(\"SDK initialization already in progress, waiting...\");\n    return initializationPromise;\n  }\n\n  // Start initialization\n  logger.info(\"Starting SDK auto-initialization from environment variables\");\n  initializationPromise = Promise.resolve().then(() => {\n    const apiKey = process.env.PINGOPS_API_KEY;\n    const baseUrl = process.env.PINGOPS_BASE_URL;\n    const serviceName = process.env.PINGOPS_SERVICE_NAME;\n    const debug = process.env.PINGOPS_DEBUG === \"true\";\n\n    logger.debug(\"Reading environment variables\", {\n      hasApiKey: !!apiKey,\n      hasBaseUrl: !!baseUrl,\n      hasServiceName: !!serviceName,\n      debug,\n    });\n\n    if (!apiKey || !baseUrl || !serviceName) {\n      const missing = [\n        !apiKey && \"PINGOPS_API_KEY\",\n        !baseUrl && \"PINGOPS_BASE_URL\",\n        !serviceName && \"PINGOPS_SERVICE_NAME\",\n      ].filter(Boolean);\n\n      logger.error(\n        \"Missing required environment variables for auto-initialization\",\n        {\n          missing,\n        }\n      );\n\n      throw new Error(\n        `PingOps SDK auto-initialization requires PINGOPS_API_KEY, PINGOPS_BASE_URL, and PINGOPS_SERVICE_NAME environment variables. Missing: ${missing.join(\", \")}`\n      );\n    }\n\n    const config: PingopsProcessorConfig = {\n      apiKey,\n      baseUrl,\n      serviceName,\n      debug,\n    };\n\n    logger.info(\"Initializing SDK with config\", {\n      baseUrl,\n      serviceName,\n      debug,\n    });\n\n    // Call initializePingops with explicit=false since this is auto-initialization\n    initializePingops(config, false);\n    isInitialized = true;\n\n    logger.info(\"SDK auto-initialization completed successfully\");\n  });\n\n  try {\n    await initializationPromise;\n  } catch (error) {\n    logger.error(\"SDK auto-initialization failed\", {\n      error: error instanceof Error ? error.message : String(error),\n    });\n    throw error;\n  } finally {\n    initializationPromise = null;\n  }\n}\n\n/**\n * Wraps a function to set attributes on HTTP spans created within the wrapped block.\n *\n * This function sets attributes (userId, sessionId, tags, metadata) in the OpenTelemetry\n * context, which are automatically propagated to all spans created within the wrapped function.\n *\n * Instrumentation behavior:\n * - If `initializePingops` was called: All HTTP requests are instrumented by default.\n *   `wrapHttp` only adds attributes to spans created within the wrapped block.\n * - If `initializePingops` was NOT called: Only HTTP requests within `wrapHttp` blocks\n *   are instrumented. Requests outside `wrapHttp` are not instrumented.\n *\n * @param options - Options including attributes to propagate to spans\n * @param fn - Function to execute within the attribute context\n * @returns The result of the function\n *\n * @example\n * ```typescript\n * import { wrapHttp } from '@pingops/sdk';\n *\n * // Scenario 1: initializePingops was called\n * initializePingops({ ... });\n *\n * // All HTTP requests are instrumented, but this block adds attributes\n * const result = await wrapHttp({\n *   attributes: {\n *     userId: 'user-123',\n *     sessionId: 'session-456',\n *     tags: ['production', 'api'],\n *     metadata: { environment: 'prod', version: '1.0.0' }\n *   }\n * }, async () => {\n *   // This HTTP request will be instrumented AND have the attributes set above\n *   const response = await fetch('https://api.example.com/users/123');\n *   return response.json();\n * });\n *\n * // HTTP requests outside wrapHttp are still instrumented, just without the attributes\n * const otherResponse = await fetch('https://api.example.com/other');\n *\n * // Scenario 2: initializePingops was NOT called\n * // Only requests within wrapHttp are instrumented\n * await wrapHttp({\n *   attributes: { userId: 'user-123' }\n * }, async () => {\n *   // This request IS instrumented\n *   return fetch('https://api.example.com/data');\n * });\n *\n * // This request is NOT instrumented (outside wrapHttp)\n * await fetch('https://api.example.com/other');\n * ```\n */\nexport function wrapHttp<T>(\n  options: { attributes?: WrapHttpAttributes },\n  fn: () => T | Promise<T>\n): T | Promise<T> {\n  return coreWrapHttp(\n    {\n      ...options,\n      checkInitialized: isSdkInitialized,\n      isGlobalInstrumentationEnabled: isGlobalInstrumentationEnabled,\n      ensureInitialized: ensureInitialized,\n    },\n    fn\n  );\n}\n"],"mappings":"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"}

package/dist/{pingops.d.ts → index.d.cts}

@@ -1,12 +1,8 @@
-/**
- * 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.
- */
-import type { PingopsProcessorConfig } from "@pingops/otel";
-import { type WrapHttpAttributes } from "@pingops/core";
+import { PingopsProcessorConfig } from "@pingops/otel";
+import { WrapHttpAttributes, WrapHttpAttributes as WrapHttpAttributes$1 } from "@pingops/core";
+
+//#region src/pingops.d.ts
+
 /**
  * Initializes PingOps SDK
  *
@@ -21,11 +17,11 @@ import { type WrapHttpAttributes } from "@pingops/core";
  * @param explicit - Whether this is an explicit call (default: true).
  *                   Set to false when called internally by wrapHttp auto-initialization.
  */
-export declare function initializePingops(config: PingopsProcessorConfig, explicit?: boolean): void;
+declare function initializePingops(config: PingopsProcessorConfig, explicit?: boolean): void;
 /**
  * Shuts down the SDK and flushes remaining spans
  */
-export declare function shutdownPingops(): Promise<void>;
+declare function shutdownPingops(): Promise<void>;
 /**
  * Wraps a function to set attributes on HTTP spans created within the wrapped block.
  *
@@ -79,7 +75,9 @@ export declare function shutdownPingops(): Promise<void>;
  * await fetch('https://api.example.com/other');
  * ```
  */
-export declare function wrapHttp<T>(options: {
-    attributes?: WrapHttpAttributes;
+declare function wrapHttp<T>(options: {
+  attributes?: WrapHttpAttributes$1;
 }, fn: () => T | Promise<T>): T | Promise<T>;
-//# sourceMappingURL=pingops.d.ts.map
+//#endregion
+export { type WrapHttpAttributes, initializePingops, shutdownPingops, wrapHttp };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -0,0 +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"}

package/dist/index.d.mts

@@ -0,0 +1,83 @@
+import { PingopsProcessorConfig } from "@pingops/otel";
+import { WrapHttpAttributes, WrapHttpAttributes as WrapHttpAttributes$1 } from "@pingops/core";
+
+//#region src/pingops.d.ts
+
+/**
+ * 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.
+ */
+declare function initializePingops(config: PingopsProcessorConfig, explicit?: boolean): void;
+/**
+ * Shuts down the SDK and flushes remaining spans
+ */
+declare function shutdownPingops(): Promise<void>;
+/**
+ * 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');
+ * ```
+ */
+declare function wrapHttp<T>(options: {
+  attributes?: WrapHttpAttributes$1;
+}, fn: () => T | Promise<T>): T | Promise<T>;
+//#endregion
+export { type WrapHttpAttributes, initializePingops, shutdownPingops, wrapHttp };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +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"}

package/dist/index.mjs

@@ -0,0 +1,246 @@
+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";
+
+//#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