@pingops/sdk 0.1.2 → 0.2.0

package/dist/index.cjs

@@ -1,248 +1,7 @@
-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-Bbm0Xd0z.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.getActiveSpanId = require_pingops.getActiveSpanId;
+exports.getActiveTraceId = require_pingops.getActiveTraceId;
+exports.initializePingops = require_pingops.initializePingops;
+exports.shutdownPingops = require_pingops.shutdownPingops;
+exports.startTrace = require_pingops.startTrace;

package/dist/index.d.cts

@@ -1,5 +1,5 @@
 import { PingopsProcessorConfig } from "@pingops/otel";
-import { WrapHttpAttributes, WrapHttpAttributes as WrapHttpAttributes$1 } from "@pingops/core";
+import { PingopsTraceAttributes, PingopsTraceAttributes as PingopsTraceAttributes$1 } from "@pingops/core";
 
 //#region src/pingops.d.ts
 
@@ -13,71 +13,60 @@ 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.
+ *                   Set to false when called internally by startTrace 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
  */
 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.
+ * Returns the trace ID of the currently active span, if any.
+ */
+declare function getActiveTraceId(): string | undefined;
+/**
+ * Returns the span ID of the currently active span, if any.
+ */
+declare function getActiveSpanId(): string | undefined;
+/**
+ * Starts a new trace using the PingOps tracer provider and runs the callback within that trace.
+ * Sets attributes (traceId, userId, sessionId, tags, metadata, etc.) in context so they are
+ * propagated to spans created within the callback.
  *
- * @param options - Options including attributes to propagate to spans
- * @param fn - Function to execute within the attribute context
- * @returns The result of the function
+ * @param options - Options including optional attributes and optional seed for deterministic traceId
+ * @param fn - Function to execute within the trace and attribute context
+ * @returns Promise resolving to the result of the function
  *
  * @example
  * ```typescript
- * import { wrapHttp } from '@pingops/sdk';
+ * import { startTrace, initializePingops } from '@pingops/sdk';
  *
- * // Scenario 1: initializePingops was called
  * initializePingops({ ... });
  *
- * // All HTTP requests are instrumented, but this block adds attributes
- * const result = await wrapHttp({
+ * const result = await startTrace({
  *   attributes: {
  *     userId: 'user-123',
  *     sessionId: 'session-456',
  *     tags: ['production', 'api'],
  *     metadata: { environment: 'prod', version: '1.0.0' }
- *   }
+ *   },
+ *   seed: 'request-123' // optional: deterministic traceId from this seed
  * }, 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>;
+declare function startTrace<T>(options: {
+  attributes?: PingopsTraceAttributes$1;
+  seed?: string;
+}, fn: () => T | Promise<T>): Promise<T>;
 //#endregion
-export { type WrapHttpAttributes, initializePingops, shutdownPingops, wrapHttp };
+export { type PingopsTraceAttributes, getActiveSpanId, getActiveTraceId, initializePingops, shutdownPingops, startTrace };
 //# sourceMappingURL=index.d.cts.map

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":";;;;;AA+SA;AAOA;AAiCA;;;;;;;;;;;;iBArRgB,iBAAA,SACN;iBAGM,iBAAA;iBAIA,iBAAA;;;;;;iBAuGM,eAAA,CAAA,GAAmB;;;;iBA8HzB,gBAAA,CAAA;;;;iBAOA,eAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiCM;eACI;;aACd,IAAI,QAAQ,KACrB,QAAQ"}

package/dist/index.d.mts

@@ -1,5 +1,5 @@
 import { PingopsProcessorConfig } from "@pingops/otel";
-import { WrapHttpAttributes, WrapHttpAttributes as WrapHttpAttributes$1 } from "@pingops/core";
+import { PingopsTraceAttributes, PingopsTraceAttributes as PingopsTraceAttributes$1 } from "@pingops/core";
 
 //#region src/pingops.d.ts
 
@@ -13,71 +13,60 @@ 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.
+ *                   Set to false when called internally by startTrace 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
  */
 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.
+ * Returns the trace ID of the currently active span, if any.
+ */
+declare function getActiveTraceId(): string | undefined;
+/**
+ * Returns the span ID of the currently active span, if any.
+ */
+declare function getActiveSpanId(): string | undefined;
+/**
+ * Starts a new trace using the PingOps tracer provider and runs the callback within that trace.
+ * Sets attributes (traceId, userId, sessionId, tags, metadata, etc.) in context so they are
+ * propagated to spans created within the callback.
  *
- * @param options - Options including attributes to propagate to spans
- * @param fn - Function to execute within the attribute context
- * @returns The result of the function
+ * @param options - Options including optional attributes and optional seed for deterministic traceId
+ * @param fn - Function to execute within the trace and attribute context
+ * @returns Promise resolving to the result of the function
  *
  * @example
  * ```typescript
- * import { wrapHttp } from '@pingops/sdk';
+ * import { startTrace, initializePingops } from '@pingops/sdk';
  *
- * // Scenario 1: initializePingops was called
  * initializePingops({ ... });
  *
- * // All HTTP requests are instrumented, but this block adds attributes
- * const result = await wrapHttp({
+ * const result = await startTrace({
  *   attributes: {
  *     userId: 'user-123',
  *     sessionId: 'session-456',
  *     tags: ['production', 'api'],
  *     metadata: { environment: 'prod', version: '1.0.0' }
- *   }
+ *   },
+ *   seed: 'request-123' // optional: deterministic traceId from this seed
  * }, 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>;
+declare function startTrace<T>(options: {
+  attributes?: PingopsTraceAttributes$1;
+  seed?: string;
+}, fn: () => T | Promise<T>): Promise<T>;
 //#endregion
-export { type WrapHttpAttributes, initializePingops, shutdownPingops, wrapHttp };
+export { type PingopsTraceAttributes, getActiveSpanId, getActiveTraceId, initializePingops, shutdownPingops, startTrace };
 //# sourceMappingURL=index.d.mts.map

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":";;;;;AA+SA;AAOA;AAiCA;;;;;;;;;;;;iBArRgB,iBAAA,SACN;iBAGM,iBAAA;iBAIA,iBAAA;;;;;;iBAuGM,eAAA,CAAA,GAAmB;;;;iBA8HzB,gBAAA,CAAA;;;;iBAOA,eAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiCM;eACI;;aACd,IAAI,QAAQ,KACrB,QAAQ"}