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

package/dist/index.mjs

@@ -0,0 +1,832 @@
+import { z } from "zod";
+import { AsyncLocalStorage } from "async_hooks";
+import pino from "pino";
+import { SpanStatusCode, SpanStatusCode as SpanStatusCode$1, context, context as context$1, metrics, propagation, propagation as propagation$1, trace, trace as trace$1 } from "@opentelemetry/api";
+import { NodeSDK } from "@opentelemetry/sdk-node";
+import { getNodeAutoInstrumentations } from "@opentelemetry/auto-instrumentations-node";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-grpc";
+import { resourceFromAttributes } from "@opentelemetry/resources";
+import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } from "@opentelemetry/semantic-conventions";
+import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-grpc";
+import { MeterProvider, PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
+import fp from "fastify-plugin";
+import { randomUUID } from "crypto";
+import axios from "axios";
+import axiosRetry from "axios-retry";
+import CircuitBreaker from "opossum";
+
+//#region src/config.ts
+const AutoInstrumentationConfigSchema = z.object({
+	http: z.boolean().default(true),
+	fastify: z.boolean().default(true),
+	express: z.boolean().default(true),
+	mongodb: z.boolean().default(true),
+	pg: z.boolean().default(true),
+	mysql: z.boolean().default(true),
+	redis: z.boolean().default(true),
+	ioredis: z.boolean().default(true),
+	grpc: z.boolean().default(true),
+	fs: z.boolean().default(false),
+	dns: z.boolean().default(false)
+}).partial();
+const FeaturesConfigSchema = z.object({
+	tracing: z.boolean().default(true),
+	metrics: z.boolean().default(true),
+	logging: z.boolean().default(true),
+	autoInstrumentation: AutoInstrumentationConfigSchema.default({})
+}).partial();
+const DEFAULT_OTEL_ENDPOINT = "http://otel-stack-deployment-collector.observability.svc.cluster.local:4317";
+const OtelConfigSchema = z.object({
+	endpoint: z.string().default(DEFAULT_OTEL_ENDPOINT),
+	metricsIntervalMs: z.number().min(1e3).default(5e3),
+	traceSampleRate: z.number().min(0).max(1).default(1)
+}).partial();
+const LoggingConfigSchema = z.object({
+	level: z.enum([
+		"debug",
+		"info",
+		"warn",
+		"error"
+	]).default("info"),
+	prettyPrint: z.boolean().optional()
+}).partial();
+const RequestLoggingConfigSchema = z.object({
+	logHeaders: z.boolean().default(true),
+	logBody: z.boolean().default(false),
+	logResponseBody: z.boolean().default(false),
+	maxBodySize: z.number().default(10 * 1024),
+	redactHeaders: z.array(z.string()).optional()
+}).partial();
+const FoundationConfigSchema = z.object({
+	serviceName: z.string().min(1, "serviceName is required"),
+	serviceVersion: z.string().default(process.env.SERVICE_VERSION || "1.0.0"),
+	environment: 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 AsyncLocalStorage();
+	return {
+		getContext: () => als.getStore(),
+		run(context$2, fn) {
+			return als.run(context$2, 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 = pino({
+		level,
+		base: {
+			service: serviceName,
+			version: serviceVersion,
+			env: environment
+		},
+		mixin: () => {
+			const span = trace$1.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 = resourceFromAttributes({
+		[ATTR_SERVICE_NAME]: serviceName,
+		[ATTR_SERVICE_VERSION]: serviceVersion,
+		"deployment.environment": environment
+	});
+	const traceExporter = new OTLPTraceExporter({ url: endpoint });
+	const instrumentationConfig = buildInstrumentationConfig(autoInstrumentation);
+	sdk = new NodeSDK({
+		resource,
+		traceExporter,
+		instrumentations: [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 trace.getTracer(name);
+}
+function getActiveSpan() {
+	return trace.getActiveSpan();
+}
+function getTraceContext() {
+	const span = 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 = resourceFromAttributes({
+		[ATTR_SERVICE_NAME]: serviceName,
+		[ATTR_SERVICE_VERSION]: serviceVersion,
+		"deployment.environment": environment
+	});
+	const metricExporter = new OTLPMetricExporter({ url: endpoint });
+	const metricReader = new PeriodicExportingMetricReader({
+		exporter: metricExporter,
+		exportIntervalMillis: intervalMs
+	});
+	meterProvider = new MeterProvider({
+		resource,
+		readers: [metricReader]
+	});
+	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 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 ? trace$1.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"] || randomUUID();
+			reply.header("x-request-id", correlationId);
+			let span;
+			let traceId = "";
+			let spanId = "";
+			if (tracer) {
+				const parentContext = propagation$1.extract(context$1.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 ? SpanStatusCode$1.OK : SpanStatusCode$1.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: SpanStatusCode$1.ERROR,
+						message: error.message
+					});
+					span.recordException(error);
+				}
+				done();
+			});
+		});
+	};
+	return fp(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.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 = {};
+			propagation$1.inject(context$1.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");
+		}
+	};
+	axiosRetry(client, retryConfig);
+	if (cbOptions.enabled !== false) {
+		const breaker = new CircuitBreaker(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: SpanStatusCode.OK });
+						span.end();
+						resolve(result);
+					} catch (err) {
+						const error = err;
+						span.setStatus({
+							code: 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
+export { AutoInstrumentationConfigSchema, FeaturesConfigSchema, FoundationConfigSchema, LoggingConfigSchema, OtelConfigSchema, RequestLoggingConfigSchema, SpanStatusCode, context, createContextManager, createFallbackLogger, createFoundation, createHttpClient, createLogger, createObservabilityPlugin, getActiveSpan, getDefaultOtelEndpoint, getGlobalLogger, getMeter, getTraceContext, getTracer, isMetricsEnabled, isTracingEnabled, metrics, parseConfig, propagation, setGlobalLogger, setupMetrics, setupObservability, setupTracing, shutdownMetrics, shutdownTracing, trace };
+//# sourceMappingURL=index.mjs.map