@ciq-dev/neoiq-foundation-node 1.0.0 → 1.0.1-beta.0

package/dist/index.js

@@ -1,30 +1,887 @@
 "use strict";
-/**
- * @commerceiq/neoiq-foundation-node
- *
- * Node.js observability foundation for CommerceIQ services.
- * Integrates with Groundcover via OpenTelemetry.
- *
- * Flow: App → OpenTelemetry SDK → OTEL Collector → Groundcover
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createHttpClient = exports.observabilityPlugin = exports.SpanStatusCode = exports.als = exports.shutdown = exports.getTraceContext = exports.runWithContext = exports.getRequestContext = exports.getMeter = exports.getTracer = exports.logger = exports.init = void 0;
-// Core initialization and logging
-var observability_1 = require("./observability");
-Object.defineProperty(exports, "init", { enumerable: true, get: function () { return observability_1.init; } });
-Object.defineProperty(exports, "logger", { enumerable: true, get: function () { return observability_1.logger; } });
-Object.defineProperty(exports, "getTracer", { enumerable: true, get: function () { return observability_1.getTracer; } });
-Object.defineProperty(exports, "getMeter", { enumerable: true, get: function () { return observability_1.getMeter; } });
-Object.defineProperty(exports, "getRequestContext", { enumerable: true, get: function () { return observability_1.getRequestContext; } });
-Object.defineProperty(exports, "runWithContext", { enumerable: true, get: function () { return observability_1.runWithContext; } });
-Object.defineProperty(exports, "getTraceContext", { enumerable: true, get: function () { return observability_1.getTraceContext; } });
-Object.defineProperty(exports, "shutdown", { enumerable: true, get: function () { return observability_1.shutdown; } });
-Object.defineProperty(exports, "als", { enumerable: true, get: function () { return observability_1.als; } });
-Object.defineProperty(exports, "SpanStatusCode", { enumerable: true, get: function () { return observability_1.SpanStatusCode; } });
-// Fastify plugin
-var plugin_1 = require("./plugin");
-Object.defineProperty(exports, "observabilityPlugin", { enumerable: true, get: function () { return plugin_1.observabilityPlugin; } });
-// HTTP client
-var http_client_1 = require("./http-client");
-Object.defineProperty(exports, "createHttpClient", { enumerable: true, get: function () { return http_client_1.createHttpClient; } });
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+const zod = __toESM(require("zod"));
+const async_hooks = __toESM(require("async_hooks"));
+const pino = __toESM(require("pino"));
+const __opentelemetry_api = __toESM(require("@opentelemetry/api"));
+const __opentelemetry_sdk_node = __toESM(require("@opentelemetry/sdk-node"));
+const __opentelemetry_auto_instrumentations_node = __toESM(require("@opentelemetry/auto-instrumentations-node"));
+const __opentelemetry_exporter_trace_otlp_grpc = __toESM(require("@opentelemetry/exporter-trace-otlp-grpc"));
+const __opentelemetry_resources = __toESM(require("@opentelemetry/resources"));
+const __opentelemetry_semantic_conventions = __toESM(require("@opentelemetry/semantic-conventions"));
+const __opentelemetry_exporter_metrics_otlp_grpc = __toESM(require("@opentelemetry/exporter-metrics-otlp-grpc"));
+const __opentelemetry_sdk_metrics = __toESM(require("@opentelemetry/sdk-metrics"));
+const fastify_plugin = __toESM(require("fastify-plugin"));
+const crypto = __toESM(require("crypto"));
+const axios = __toESM(require("axios"));
+const axios_retry = __toESM(require("axios-retry"));
+const opossum = __toESM(require("opossum"));
+
+//#region src/config.ts
+const AutoInstrumentationConfigSchema = zod.z.object({
+	http: zod.z.boolean().default(true),
+	fastify: zod.z.boolean().default(true),
+	express: zod.z.boolean().default(true),
+	mongodb: zod.z.boolean().default(true),
+	pg: zod.z.boolean().default(true),
+	mysql: zod.z.boolean().default(true),
+	redis: zod.z.boolean().default(true),
+	ioredis: zod.z.boolean().default(true),
+	grpc: zod.z.boolean().default(true),
+	fs: zod.z.boolean().default(false),
+	dns: zod.z.boolean().default(false)
+}).partial();
+const FeaturesConfigSchema = zod.z.object({
+	tracing: zod.z.boolean().default(true),
+	metrics: zod.z.boolean().default(true),
+	logging: zod.z.boolean().default(true),
+	autoInstrumentation: AutoInstrumentationConfigSchema.default({})
+}).partial();
+const DEFAULT_OTEL_ENDPOINT = "http://otel-stack-deployment-collector.observability.svc.cluster.local:4317";
+const OtelConfigSchema = zod.z.object({
+	endpoint: zod.z.string().default(DEFAULT_OTEL_ENDPOINT),
+	metricsIntervalMs: zod.z.number().min(1e3).default(5e3),
+	traceSampleRate: zod.z.number().min(0).max(1).default(1)
+}).partial();
+const LoggingConfigSchema = zod.z.object({
+	level: zod.z.enum([
+		"debug",
+		"info",
+		"warn",
+		"error"
+	]).default("info"),
+	prettyPrint: zod.z.boolean().optional()
+}).partial();
+const RequestLoggingConfigSchema = zod.z.object({
+	logHeaders: zod.z.boolean().default(true),
+	logBody: zod.z.boolean().default(false),
+	logResponseBody: zod.z.boolean().default(false),
+	maxBodySize: zod.z.number().default(10 * 1024),
+	redactHeaders: zod.z.array(zod.z.string()).optional()
+}).partial();
+const FoundationConfigSchema = zod.z.object({
+	serviceName: zod.z.string().min(1, "serviceName is required"),
+	serviceVersion: zod.z.string().default(process.env.SERVICE_VERSION || "1.0.0"),
+	environment: zod.z.enum([
+		"development",
+		"staging",
+		"qa",
+		"production"
+	]).default(process.env.NODE_ENV || "development"),
+	features: FeaturesConfigSchema.default({}),
+	otel: OtelConfigSchema.default({}),
+	logging: LoggingConfigSchema.default({}),
+	requestLogging: RequestLoggingConfigSchema.default({})
+});
+/** Parse and validate configuration */
+function parseConfig(input) {
+	const result = FoundationConfigSchema.safeParse(input);
+	if (!result.success) {
+		const errors = result.error.errors.map((e) => `  - ${e.path.join(".")}: ${e.message}`).join("\n");
+		throw new Error(`Invalid foundation configuration:\n${errors}`);
+	}
+	return result.data;
+}
+/** Get default OTEL endpoint */
+function getDefaultOtelEndpoint() {
+	return process.env.OTEL_EXPORTER_OTLP_ENDPOINT || DEFAULT_OTEL_ENDPOINT;
+}
+
+//#endregion
+//#region src/features/context.ts
+/** Create a new context manager instance */
+function createContextManager() {
+	const als = new async_hooks.AsyncLocalStorage();
+	return {
+		getContext: () => als.getStore(),
+		run(context$3, fn) {
+			return als.run(context$3, fn);
+		},
+		get(key) {
+			return als.getStore()?.[key];
+		},
+		update(updates) {
+			const current = als.getStore();
+			if (!current) return void 0;
+			Object.assign(current, updates);
+			return current;
+		}
+	};
+}
+
+//#endregion
+//#region src/features/logging.ts
+/** Create a structured logger with automatic trace context injection */
+function createLogger(options) {
+	const { serviceName, serviceVersion, environment, level, prettyPrint, contextManager } = options;
+	const pinoLogger = (0, pino.default)({
+		level,
+		base: {
+			service: serviceName,
+			version: serviceVersion,
+			env: environment
+		},
+		mixin: () => {
+			const span = __opentelemetry_api.trace.getActiveSpan();
+			const spanContext = span?.spanContext();
+			const ctx = contextManager?.getContext();
+			return {
+				traceId: spanContext?.traceId || ctx?.traceId,
+				spanId: spanContext?.spanId || ctx?.spanId,
+				correlationId: ctx?.correlationId
+			};
+		},
+		formatters: { level: (label) => ({ level: label }) },
+		transport: prettyPrint ? {
+			target: "pino-pretty",
+			options: {
+				colorize: true,
+				translateTime: "SYS:standard",
+				ignore: "pid,hostname"
+			}
+		} : void 0
+	});
+	return wrapPinoLogger(pinoLogger);
+}
+function wrapPinoLogger(pinoLogger) {
+	return {
+		debug: (obj, msg) => pinoLogger.debug(obj, msg),
+		info: (obj, msg) => pinoLogger.info(obj, msg),
+		warn: (obj, msg) => pinoLogger.warn(obj, msg),
+		error: (obj, msg) => pinoLogger.error(obj, msg),
+		child: (bindings) => wrapPinoLogger(pinoLogger.child(bindings)),
+		pino: pinoLogger
+	};
+}
+/** Fallback logger when Pino is not available */
+function createFallbackLogger(serviceName = "unknown") {
+	const log = (level, obj, msg) => {
+		const logObj = {
+			timestamp: new Date().toISOString(),
+			level,
+			service: serviceName,
+			...obj,
+			msg
+		};
+		console[level === "debug" ? "log" : level](JSON.stringify(logObj));
+	};
+	const fallback = {
+		debug: (obj, msg) => log("debug", obj, msg),
+		info: (obj, msg) => log("info", obj, msg),
+		warn: (obj, msg) => log("warn", obj, msg),
+		error: (obj, msg) => log("error", obj, msg),
+		child: () => fallback,
+		pino: null
+	};
+	return fallback;
+}
+let globalLogger = null;
+function setGlobalLogger(logger) {
+	globalLogger = logger;
+}
+function getGlobalLogger() {
+	return globalLogger || createFallbackLogger();
+}
+
+//#endregion
+//#region src/features/tracing.ts
+let sdk = null;
+let isInitialized$1 = false;
+/** Initialize OpenTelemetry tracing */
+function setupTracing(options) {
+	if (isInitialized$1) {
+		console.warn("[neoiq-foundation] Tracing already initialized");
+		return;
+	}
+	const { serviceName, serviceVersion, environment, endpoint = getDefaultOtelEndpoint(), autoInstrumentation = {} } = options;
+	const resource = (0, __opentelemetry_resources.resourceFromAttributes)({
+		[__opentelemetry_semantic_conventions.ATTR_SERVICE_NAME]: serviceName,
+		[__opentelemetry_semantic_conventions.ATTR_SERVICE_VERSION]: serviceVersion,
+		"deployment.environment": environment
+	});
+	const traceExporter = new __opentelemetry_exporter_trace_otlp_grpc.OTLPTraceExporter({ url: endpoint });
+	const instrumentationConfig = buildInstrumentationConfig(autoInstrumentation);
+	sdk = new __opentelemetry_sdk_node.NodeSDK({
+		resource,
+		traceExporter,
+		instrumentations: [(0, __opentelemetry_auto_instrumentations_node.getNodeAutoInstrumentations)(instrumentationConfig)]
+	});
+	sdk.start();
+	isInitialized$1 = true;
+}
+function buildInstrumentationConfig(config) {
+	const mapping = {
+		http: "@opentelemetry/instrumentation-http",
+		fastify: "@opentelemetry/instrumentation-fastify",
+		express: "@opentelemetry/instrumentation-express",
+		mongodb: "@opentelemetry/instrumentation-mongodb",
+		pg: "@opentelemetry/instrumentation-pg",
+		mysql: "@opentelemetry/instrumentation-mysql",
+		redis: "@opentelemetry/instrumentation-redis",
+		ioredis: "@opentelemetry/instrumentation-ioredis",
+		grpc: "@opentelemetry/instrumentation-grpc",
+		fs: "@opentelemetry/instrumentation-fs",
+		dns: "@opentelemetry/instrumentation-dns"
+	};
+	const result = {};
+	for (const [key, instrumentationName] of Object.entries(mapping)) {
+		const userSetting = config[key];
+		const defaultValue = key !== "fs" && key !== "dns";
+		result[instrumentationName] = { enabled: userSetting ?? defaultValue };
+	}
+	return result;
+}
+/** Shutdown tracing gracefully */
+async function shutdownTracing() {
+	if (!sdk) return;
+	try {
+		await sdk.shutdown();
+		isInitialized$1 = false;
+		sdk = null;
+	} catch (error) {
+		console.error("[neoiq-foundation] Error shutting down tracing:", error);
+	}
+}
+function getTracer(name) {
+	return __opentelemetry_api.trace.getTracer(name);
+}
+function getActiveSpan() {
+	return __opentelemetry_api.trace.getActiveSpan();
+}
+function getTraceContext() {
+	const span = __opentelemetry_api.trace.getActiveSpan();
+	if (!span) return {};
+	const ctx = span.spanContext();
+	return {
+		traceId: ctx.traceId,
+		spanId: ctx.spanId
+	};
+}
+function isTracingEnabled() {
+	return isInitialized$1;
+}
+
+//#endregion
+//#region src/features/metrics.ts
+let meterProvider = null;
+let isInitialized = false;
+/** Initialize OpenTelemetry metrics */
+function setupMetrics(options) {
+	if (isInitialized) {
+		console.warn("[neoiq-foundation] Metrics already initialized");
+		return;
+	}
+	const { serviceName, serviceVersion, environment, endpoint = getDefaultOtelEndpoint(), intervalMs = 5e3 } = options;
+	const resource = (0, __opentelemetry_resources.resourceFromAttributes)({
+		[__opentelemetry_semantic_conventions.ATTR_SERVICE_NAME]: serviceName,
+		[__opentelemetry_semantic_conventions.ATTR_SERVICE_VERSION]: serviceVersion,
+		"deployment.environment": environment
+	});
+	const metricExporter = new __opentelemetry_exporter_metrics_otlp_grpc.OTLPMetricExporter({ url: endpoint });
+	const metricReader = new __opentelemetry_sdk_metrics.PeriodicExportingMetricReader({
+		exporter: metricExporter,
+		exportIntervalMillis: intervalMs
+	});
+	meterProvider = new __opentelemetry_sdk_metrics.MeterProvider({
+		resource,
+		readers: [metricReader]
+	});
+	__opentelemetry_api.metrics.setGlobalMeterProvider(meterProvider);
+	isInitialized = true;
+}
+/** Shutdown metrics gracefully */
+async function shutdownMetrics() {
+	if (!meterProvider) return;
+	try {
+		await meterProvider.shutdown();
+		isInitialized = false;
+		meterProvider = null;
+	} catch (error) {
+		console.error("[neoiq-foundation] Error shutting down metrics:", error);
+	}
+}
+function getMeter(name, version = "1.0.0") {
+	return __opentelemetry_api.metrics.getMeter(name, version);
+}
+function isMetricsEnabled() {
+	return isInitialized;
+}
+
+//#endregion
+//#region src/integrations/fastify-plugin.ts
+const DEFAULT_REDACT_HEADERS = [
+	"authorization",
+	"cookie",
+	"x-api-key",
+	"x-auth-token",
+	"set-cookie"
+];
+/** Redact sensitive headers */
+function redactHeaders(headers, redactList) {
+	const redacted = {};
+	for (const [key, value] of Object.entries(headers)) if (redactList.includes(key.toLowerCase())) redacted[key] = "[REDACTED]";
+	else redacted[key] = value;
+	return redacted;
+}
+/** Truncate body if too large */
+function truncateBody(body, maxSize) {
+	if (body === void 0 || body === null) return void 0;
+	const str = typeof body === "string" ? body : JSON.stringify(body);
+	if (str.length > maxSize) return `[TRUNCATED - ${str.length} bytes]`;
+	return body;
+}
+/** Create a configured Fastify observability plugin */
+function createObservabilityPlugin(options) {
+	const plugin = async (fastify, pluginOpts) => {
+		const { serviceName, logger = getGlobalLogger(), contextManager, tracingEnabled = true, metricsEnabled = true, excludeRoutes = [
+			"/health",
+			"/health/",
+			"/healthz",
+			"/ready",
+			"/live"
+		], requestLogging = {} } = {
+			...options,
+			...pluginOpts
+		};
+		const logHeaders = requestLogging.logHeaders ?? true;
+		const logBody = requestLogging.logBody ?? false;
+		const logResponseBody = requestLogging.logResponseBody ?? false;
+		const maxBodySize = requestLogging.maxBodySize ?? 10 * 1024;
+		const headersToRedact = requestLogging.redactHeaders ?? DEFAULT_REDACT_HEADERS;
+		const runInContext = contextManager ? (ctx, fn) => contextManager.run(ctx, fn) : (_ctx, fn) => fn();
+		const tracer = tracingEnabled ? __opentelemetry_api.trace.getTracer("neoiq-foundation-node") : null;
+		let requestCounter;
+		let requestDuration;
+		let requestErrors;
+		if (metricsEnabled) {
+			const meter = getMeter(serviceName);
+			requestCounter = meter.createCounter("http.server.requests.total");
+			requestDuration = meter.createHistogram("http.server.request.duration", { unit: "ms" });
+			requestErrors = meter.createCounter("http.server.requests.errors");
+		}
+		fastify.addHook("onRequest", (request, reply, done) => {
+			if (excludeRoutes.some((route) => request.url.startsWith(route))) {
+				done();
+				return;
+			}
+			const correlationId = request.headers["x-request-id"] || (0, crypto.randomUUID)();
+			reply.header("x-request-id", correlationId);
+			let span;
+			let traceId = "";
+			let spanId = "";
+			if (tracer) {
+				const parentContext = __opentelemetry_api.propagation.extract(__opentelemetry_api.context.active(), request.headers);
+				span = tracer.startSpan(`${request.method} ${request.routeOptions?.url || request.url}`, {
+					kind: 1,
+					attributes: {
+						"http.method": request.method,
+						"http.url": request.url,
+						"http.route": request.routeOptions?.url || request.url,
+						"http.user_agent": request.headers["user-agent"] || "",
+						"http.correlation_id": correlationId
+					}
+				}, parentContext);
+				const spanContext = span.spanContext();
+				traceId = spanContext.traceId;
+				spanId = spanContext.spanId;
+			}
+			const requestContext = {
+				correlationId,
+				traceId,
+				spanId,
+				startTime: Date.now()
+			};
+			request.__span = span;
+			request.__requestContext = requestContext;
+			runInContext(requestContext, () => {
+				const logData = {
+					correlationId,
+					traceId: traceId || void 0,
+					method: request.method,
+					url: request.url,
+					ip: request.ip,
+					userAgent: request.headers["user-agent"]
+				};
+				if (logHeaders) logData.headers = redactHeaders(request.headers, headersToRedact);
+				logger.info(logData, "Request received");
+				done();
+			});
+		});
+		if (logBody) fastify.addHook("preHandler", (request, _reply, done) => {
+			const ctx = request.__requestContext;
+			if (!ctx || !request.body) {
+				done();
+				return;
+			}
+			runInContext(ctx, () => {
+				logger.debug({
+					correlationId: ctx.correlationId,
+					body: truncateBody(request.body, maxBodySize)
+				}, "Request body");
+				done();
+			});
+		});
+		if (logResponseBody) fastify.addHook("onSend", (request, reply, payload, done) => {
+			const ctx = request.__requestContext;
+			if (!ctx) {
+				done(null, payload);
+				return;
+			}
+			runInContext(ctx, () => {
+				logger.debug({
+					correlationId: ctx.correlationId,
+					statusCode: reply.statusCode,
+					body: truncateBody(payload, maxBodySize)
+				}, "Response body");
+				done(null, payload);
+			});
+		});
+		fastify.addHook("onResponse", (request, reply, done) => {
+			const ctx = request.__requestContext;
+			const span = request.__span;
+			if (!ctx) {
+				done();
+				return;
+			}
+			const durationMs = Date.now() - ctx.startTime;
+			const route = request.routeOptions?.url || request.url;
+			const labels = {
+				method: request.method,
+				route,
+				status_code: String(reply.statusCode)
+			};
+			runInContext(ctx, () => {
+				logger.info({
+					correlationId: ctx.correlationId,
+					method: request.method,
+					statusCode: reply.statusCode,
+					durationMs
+				}, "Request completed");
+				if (metricsEnabled) {
+					requestCounter.add(1, labels);
+					requestDuration.record(durationMs, labels);
+					if (reply.statusCode >= 400) requestErrors.add(1, labels);
+				}
+				if (span) {
+					span.setStatus({ code: reply.statusCode < 400 ? __opentelemetry_api.SpanStatusCode.OK : __opentelemetry_api.SpanStatusCode.ERROR });
+					span.setAttribute("http.status_code", reply.statusCode);
+					span.setAttribute("http.response_time_ms", durationMs);
+					span.end();
+				}
+				done();
+			});
+		});
+		fastify.addHook("onError", (request, _reply, error, done) => {
+			const ctx = request.__requestContext;
+			const span = request.__span;
+			if (!ctx) {
+				done();
+				return;
+			}
+			runInContext(ctx, () => {
+				logger.error({
+					correlationId: ctx.correlationId,
+					method: request.method,
+					url: request.url,
+					error: error.message
+				}, "Request failed");
+				if (span) {
+					span.setStatus({
+						code: __opentelemetry_api.SpanStatusCode.ERROR,
+						message: error.message
+					});
+					span.recordException(error);
+				}
+				done();
+			});
+		});
+	};
+	return (0, fastify_plugin.default)(plugin, {
+		name: "neoiq-observability",
+		fastify: ">=4.x"
+	});
+}
+
+//#endregion
+//#region src/integrations/http-client.ts
+/** Create a configured HTTP client with full observability */
+function createHttpClient(options) {
+	const { baseURL, serviceName, timeout = 3e4, retry = {}, circuitBreaker: cbOptions = {}, headers = {}, foundation } = options;
+	const logger = foundation?.logger || getGlobalLogger();
+	const getContext = () => foundation?.context.getContext();
+	const metricsEnabled = foundation?.features.metrics ?? true;
+	const tracingEnabled = foundation?.features.tracing ?? true;
+	const client = axios.default.create({
+		baseURL,
+		timeout,
+		headers: {
+			"Content-Type": "application/json",
+			...headers
+		}
+	});
+	let requestCounter = null;
+	let requestDuration = null;
+	let requestErrors = null;
+	if (metricsEnabled) {
+		const meter = getMeter(`http-client-${serviceName}`);
+		requestCounter = meter.createCounter("http.client.requests.total");
+		requestDuration = meter.createHistogram("http.client.request.duration", { unit: "ms" });
+		requestErrors = meter.createCounter("http.client.requests.errors");
+	}
+	client.interceptors.request.use((config) => {
+		if (tracingEnabled) {
+			const carrier = {};
+			__opentelemetry_api.propagation.inject(__opentelemetry_api.context.active(), carrier);
+			if (carrier.traceparent) config.headers.set("traceparent", carrier.traceparent);
+			if (carrier.tracestate) config.headers.set("tracestate", carrier.tracestate);
+		}
+		const reqCtx = getContext();
+		if (reqCtx?.correlationId) config.headers.set("x-request-id", reqCtx.correlationId);
+		config.__startTime = Date.now();
+		logger.debug({
+			method: config.method?.toUpperCase(),
+			url: `${config.baseURL || ""}${config.url}`,
+			targetService: serviceName
+		}, "Outbound HTTP request");
+		return config;
+	});
+	client.interceptors.response.use((response) => {
+		const config = response.config;
+		const durationMs = Date.now() - (config.__startTime || Date.now());
+		const labels = {
+			target_service: serviceName,
+			method: config.method?.toUpperCase() || "GET",
+			status_code: String(response.status)
+		};
+		logger.debug({
+			method: config.method?.toUpperCase(),
+			statusCode: response.status,
+			durationMs,
+			targetService: serviceName
+		}, "Outbound HTTP response");
+		if (metricsEnabled) {
+			requestCounter?.add(1, labels);
+			requestDuration?.record(durationMs, labels);
+		}
+		return response;
+	}, (error) => {
+		const config = error.config;
+		const durationMs = config ? Date.now() - (config.__startTime || Date.now()) : 0;
+		const statusCode = error.response?.status || 0;
+		const labels = {
+			target_service: serviceName,
+			method: config?.method?.toUpperCase() || "GET",
+			status_code: String(statusCode)
+		};
+		logger.error({
+			method: config?.method?.toUpperCase(),
+			statusCode,
+			durationMs,
+			error: error.message,
+			targetService: serviceName
+		}, "Outbound HTTP error");
+		if (metricsEnabled) {
+			requestCounter?.add(1, labels);
+			requestDuration?.record(durationMs, labels);
+			requestErrors?.add(1, labels);
+		}
+		return Promise.reject(error);
+	});
+	const retryConfig = {
+		retries: retry.retries ?? 3,
+		retryDelay: (retryCount) => (retry.retryDelay ?? 1e3) * Math.pow(2, retryCount - 1),
+		retryCondition: (error) => {
+			const retryStatusCodes = retry.retryStatusCodes ?? [
+				408,
+				429,
+				500,
+				502,
+				503,
+				504
+			];
+			return !error.response || retryStatusCodes.includes(error.response?.status || 0);
+		},
+		onRetry: (retryCount, error, requestConfig) => {
+			logger.warn({
+				retryCount,
+				url: `${requestConfig.baseURL || ""}${requestConfig.url}`,
+				error: error.message
+			}, "Retrying request");
+		}
+	};
+	(0, axios_retry.default)(client, retryConfig);
+	if (cbOptions.enabled !== false) {
+		const breaker = new opossum.default(async (config) => client.request(config), {
+			timeout,
+			resetTimeout: cbOptions.resetTimeout ?? 3e4,
+			errorThresholdPercentage: cbOptions.errorThresholdPercentage ?? 50,
+			volumeThreshold: 10
+		});
+		breaker.on("open", () => logger.warn({ targetService: serviceName }, "Circuit breaker OPEN"));
+		breaker.on("halfOpen", () => logger.info({ targetService: serviceName }, "Circuit breaker HALF-OPEN"));
+		breaker.on("close", () => logger.info({ targetService: serviceName }, "Circuit breaker CLOSED"));
+	}
+	return client;
+}
+
+//#endregion
+//#region src/foundation.ts
+/** Create a fully configured observability foundation */
+function createFoundation(input) {
+	const startTime = Date.now();
+	const config = parseConfig(input);
+	const { serviceName, serviceVersion, environment, features: featuresConfig, otel, logging: loggingConfig, requestLogging: requestLoggingConfig } = config;
+	const features = {
+		tracing: featuresConfig.tracing ?? true,
+		metrics: featuresConfig.metrics ?? true,
+		logging: featuresConfig.logging ?? true
+	};
+	const contextManager = createContextManager();
+	let logger;
+	let loggingError;
+	try {
+		logger = createLogger({
+			serviceName,
+			serviceVersion,
+			environment,
+			level: loggingConfig.level ?? "info",
+			prettyPrint: loggingConfig.prettyPrint ?? environment === "development",
+			contextManager
+		});
+		setGlobalLogger(logger);
+	} catch (err) {
+		loggingError = err.message;
+		logger = {
+			debug: (obj, msg) => console.debug(JSON.stringify({
+				...obj,
+				msg
+			})),
+			info: (obj, msg) => console.info(JSON.stringify({
+				...obj,
+				msg
+			})),
+			warn: (obj, msg) => console.warn(JSON.stringify({
+				...obj,
+				msg
+			})),
+			error: (obj, msg) => console.error(JSON.stringify({
+				...obj,
+				msg
+			})),
+			child: () => logger,
+			pino: null
+		};
+		console.error("[neoiq-foundation] Logger setup failed, using console:", loggingError);
+	}
+	let tracerInstance = null;
+	let tracingError;
+	if (features.tracing) try {
+		setupTracing({
+			serviceName,
+			serviceVersion,
+			environment,
+			endpoint: otel.endpoint,
+			sampleRate: otel.traceSampleRate,
+			autoInstrumentation: featuresConfig.autoInstrumentation
+		});
+		tracerInstance = getTracer(serviceName);
+		logger.info({
+			feature: "tracing",
+			endpoint: otel.endpoint
+		}, "Tracing enabled");
+	} catch (err) {
+		tracingError = err.message;
+		logger.error({ error: tracingError }, "Tracing setup failed - continuing without tracing");
+	}
+	let meterInstance = null;
+	let metricsError;
+	if (features.metrics) try {
+		setupMetrics({
+			serviceName,
+			serviceVersion,
+			environment,
+			endpoint: otel.endpoint,
+			intervalMs: otel.metricsIntervalMs
+		});
+		meterInstance = getMeter(serviceName);
+		logger.info({
+			feature: "metrics",
+			interval: `${otel.metricsIntervalMs}ms`
+		}, "Metrics enabled");
+	} catch (err) {
+		metricsError = err.message;
+		logger.error({ error: metricsError }, "Metrics setup failed - continuing without metrics");
+	}
+	logger.info({
+		serviceName,
+		serviceVersion,
+		environment,
+		features
+	}, "Foundation initialized");
+	const foundation = {
+		config,
+		logger,
+		context: contextManager,
+		tracer: tracerInstance,
+		meter: meterInstance,
+		features,
+		getTracer: (name) => getTracer(name || serviceName),
+		getMeter: (name, version) => getMeter(name, version),
+		getTraceContext,
+		getActiveSpan,
+		fastifyPlugin: createObservabilityPlugin({
+			serviceName,
+			logger,
+			contextManager,
+			tracingEnabled: features.tracing && !tracingError,
+			metricsEnabled: features.metrics && !metricsError,
+			requestLogging: requestLoggingConfig
+		}),
+		createHttpClient: (options) => createHttpClient({
+			...options,
+			foundation
+		}),
+		shutdown: async () => {
+			logger.info({}, "Shutting down foundation...");
+			const promises = [];
+			if (features.tracing && isTracingEnabled()) promises.push(shutdownTracing());
+			if (features.metrics && isMetricsEnabled()) promises.push(shutdownMetrics());
+			await Promise.all(promises);
+			logger.info({}, "Foundation shutdown complete");
+		},
+		isReady: () => {
+			if (features.tracing && !tracingError && !isTracingEnabled()) return false;
+			if (features.metrics && !metricsError && !isMetricsEnabled()) return false;
+			return true;
+		},
+		health: () => {
+			const tracingUp = !features.tracing || !tracingError && isTracingEnabled();
+			const metricsUp = !features.metrics || !metricsError && isMetricsEnabled();
+			const loggingUp = !loggingError;
+			const allUp = tracingUp && metricsUp && loggingUp;
+			const anyDown = features.tracing && tracingError || features.metrics && metricsError || loggingError;
+			return {
+				status: allUp ? "healthy" : anyDown ? "degraded" : "unhealthy",
+				timestamp: new Date().toISOString(),
+				service: serviceName,
+				version: serviceVersion,
+				uptime: Math.floor((Date.now() - startTime) / 1e3),
+				components: {
+					tracing: {
+						enabled: features.tracing,
+						status: !features.tracing ? "disabled" : tracingError ? "down" : "up",
+						message: tracingError
+					},
+					metrics: {
+						enabled: features.metrics,
+						status: !features.metrics ? "disabled" : metricsError ? "down" : "up",
+						message: metricsError
+					},
+					logging: {
+						enabled: features.logging,
+						status: loggingError ? "down" : "up",
+						message: loggingError
+					}
+				}
+			};
+		},
+		trace: async (name, fn) => {
+			const tracer = tracerInstance || getTracer(serviceName);
+			return new Promise((resolve, reject) => {
+				tracer.startActiveSpan(name, async (span) => {
+					try {
+						const result = await fn();
+						span.setStatus({ code: __opentelemetry_api.SpanStatusCode.OK });
+						span.end();
+						resolve(result);
+					} catch (err) {
+						const error = err;
+						span.setStatus({
+							code: __opentelemetry_api.SpanStatusCode.ERROR,
+							message: error.message
+						});
+						span.recordException(error);
+						span.end();
+						logger.error({
+							span: name,
+							error: error.message
+						}, "Span failed");
+						reject(error);
+					}
+				});
+			});
+		},
+		safeRun: async (fn, fallback) => {
+			try {
+				return await fn();
+			} catch (err) {
+				const error = err;
+				logger.error({
+					error: error.message,
+					stack: error.stack
+				}, "safeRun caught error");
+				return fallback;
+			}
+		}
+	};
+	return foundation;
+}
+/** Alias for createFoundation */
+const setupObservability = createFoundation;
+
+//#endregion
+exports.AutoInstrumentationConfigSchema = AutoInstrumentationConfigSchema
+exports.FeaturesConfigSchema = FeaturesConfigSchema
+exports.FoundationConfigSchema = FoundationConfigSchema
+exports.LoggingConfigSchema = LoggingConfigSchema
+exports.OtelConfigSchema = OtelConfigSchema
+exports.RequestLoggingConfigSchema = RequestLoggingConfigSchema
+exports.SpanStatusCode = __opentelemetry_api.SpanStatusCode
+exports.context = __opentelemetry_api.context
+exports.createContextManager = createContextManager
+exports.createFallbackLogger = createFallbackLogger
+exports.createFoundation = createFoundation
+exports.createHttpClient = createHttpClient
+exports.createLogger = createLogger
+exports.createObservabilityPlugin = createObservabilityPlugin
+exports.getActiveSpan = getActiveSpan
+exports.getDefaultOtelEndpoint = getDefaultOtelEndpoint
+exports.getGlobalLogger = getGlobalLogger
+exports.getMeter = getMeter
+exports.getTraceContext = getTraceContext
+exports.getTracer = getTracer
+exports.isMetricsEnabled = isMetricsEnabled
+exports.isTracingEnabled = isTracingEnabled
+exports.metrics = __opentelemetry_api.metrics
+exports.parseConfig = parseConfig
+exports.propagation = __opentelemetry_api.propagation
+exports.setGlobalLogger = setGlobalLogger
+exports.setupMetrics = setupMetrics
+exports.setupObservability = setupObservability
+exports.setupTracing = setupTracing
+exports.shutdownMetrics = shutdownMetrics
+exports.shutdownTracing = shutdownTracing
+exports.trace = __opentelemetry_api.trace
 //# sourceMappingURL=index.js.map