@ciq-dev/neoiq-foundation-node 1.0.1-beta.2 → 1.0.1-beta.3

package/dist/index.mjs

@@ -1,13 +1,9 @@
-import { createRequire } from "module";
-import { z } from "zod";
-import { AsyncLocalStorage } from "async_hooks";
-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 pino from "pino";
-import { NodeSDK } from "@opentelemetry/sdk-node";
-import { getNodeAutoInstrumentations } from "@opentelemetry/auto-instrumentations-node";
-import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-grpc";
+import { AutoInstrumentationConfigSchema, FeaturesConfigSchema, FoundationConfigSchema, LoggingConfigSchema, OtelConfigSchema, RedactionConfigSchema, RequestLoggingConfigSchema, ShutdownConfigSchema, SpanStatusCode, context, getActiveSpan, getDefaultOtelEndpoint, getTraceContext, getTracer, isTracingEnabled, parseConfig, propagation, setupTracing, shutdownTracing, trace } from "./tracing-Cv-Y3fZx.mjs";
 import { resourceFromAttributes } from "@opentelemetry/resources";
 import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } from "@opentelemetry/semantic-conventions";
+import { SpanStatusCode as SpanStatusCode$1, context as context$1, metrics, propagation as propagation$1, trace as trace$1 } from "@opentelemetry/api";
+import { AsyncLocalStorage } from "async_hooks";
+import pino from "pino";
 import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-grpc";
 import { MeterProvider, PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
 import fp from "fastify-plugin";
@@ -15,90 +11,9 @@ import { randomUUID } from "crypto";
 import axios from "axios";
 import axiosRetry from "axios-retry";
 import CircuitBreaker from "opossum";
+import { createHash } from "node:crypto";
 import { Readable } from "node:stream";
 
-//#region rolldown:runtime
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
-
-//#endregion
-//#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 RedactionConfigSchema = z.object({ additionalPaths: z.array(z.string()).default([]) }).partial();
-const ShutdownConfigSchema = z.object({
-	flushOnCrash: z.boolean().default(false),
-	flushTimeoutMs: z.number().min(100).default(5e3)
-}).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({}),
-	redaction: RedactionConfigSchema.default({}),
-	shutdown: ShutdownConfigSchema.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
 const BAGGAGE_CORRELATION_KEY = "correlation.id";
 function setBaggageCorrelationId(correlationId) {
@@ -385,12 +300,13 @@ function wrapPinoLogger(pinoLogger) {
 	};
 }
 /** Fallback logger when Pino is not available */
-function createFallbackLogger(serviceName = "unknown") {
+function createFallbackLogger(serviceName = "unknown", baseBindings = {}) {
 	const log = (level, obj, msg) => {
 		const logObj = {
 			timestamp: new Date().toISOString(),
 			level,
 			service: serviceName,
+			...baseBindings,
 			...obj,
 			msg
 		};
@@ -404,7 +320,10 @@ function createFallbackLogger(serviceName = "unknown") {
 		info: (obj, msg) => log("info", obj, msg),
 		warn: (obj, msg) => log("warn", obj, msg),
 		error: (obj, msg) => log("error", obj, msg),
-		child: () => fallback,
+		child: (bindings) => createFallbackLogger(serviceName, {
+			...baseBindings,
+			...bindings
+		}),
 		pino: null
 	};
 	return fallback;
@@ -417,98 +336,6 @@ function getGlobalLogger() {
 	return globalLogger || createFallbackLogger();
 }
 
-//#endregion
-//#region src/features/tracing.ts
-let sdk = null;
-let isInitialized$1 = false;
-const MONITORED_MODULES = [
-	"pg",
-	"mongodb",
-	"ioredis",
-	"mysql2",
-	"express",
-	"@grpc/grpc-js"
-];
-function warnPreloadedModules() {
-	for (const mod of MONITORED_MODULES) try {
-		if (__require.resolve(mod) in (__require.cache || {})) console.warn(`[neoiq-foundation] "${mod}" was imported before tracing init. Auto-instrumentation may not work for this module. Use node -r @ciq-dev/neoiq-foundation-node/bootstrap or call createFoundation() first.`);
-	} catch {}
-}
-/** Initialize OpenTelemetry tracing */
-function setupTracing(options) {
-	if (isInitialized$1) {
-		console.warn("[neoiq-foundation] Tracing already initialized");
-		return;
-	}
-	warnPreloadedModules();
-	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;
@@ -546,6 +373,7 @@ async function shutdownMetrics() {
 		meterProvider = null;
 	} catch (error) {
 		console.error("[neoiq-foundation] Error shutting down metrics:", error);
+		throw error;
 	}
 }
 function getMeter(name, version = "1.0.0") {
@@ -823,31 +651,34 @@ function createHttpClient(options) {
 		}
 		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), {
+	if (retry.enabled !== false) {
+		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 === true) {
+		const originalRequest = client.request.bind(client);
+		const breaker = new CircuitBreaker(async (config) => originalRequest(config), {
 			timeout,
 			resetTimeout: cbOptions.resetTimeout ?? 3e4,
 			errorThresholdPercentage: cbOptions.errorThresholdPercentage ?? 50,
@@ -856,7 +687,6 @@ function createHttpClient(options) {
 		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"));
-		const originalRequest = client.request.bind(client);
 		client.request = (config) => breaker.fire(config);
 		client.get = (url, config) => breaker.fire({
 			...config,
@@ -894,10 +724,15 @@ function createHttpClient(options) {
 //#endregion
 //#region src/foundation.ts
 const deprecationWarnings = new Set();
-function warnDeprecation(oldPath, newPath) {
+function warnDeprecation(oldPath, newPath, logger) {
 	if (deprecationWarnings.has(oldPath)) return;
 	deprecationWarnings.add(oldPath);
-	console.warn(`[neoiq-foundation] DEPRECATED: foundation.${oldPath}() is deprecated. Use foundation.${newPath}() instead. This alias will be removed in the next major version.`);
+	const msg = `foundation.${oldPath}() is deprecated. Use foundation.${newPath}() instead. This alias will be removed in the next major version.`;
+	if (logger) logger.warn({
+		deprecated: oldPath,
+		replacement: newPath
+	}, msg);
+	else console.warn(`[neoiq-foundation] DEPRECATED: ${msg}`);
 }
 /** Create a fully configured observability foundation */
 function createFoundation(input) {
@@ -1058,9 +893,11 @@ function createFoundation(input) {
 		const metricsUp = !features.metrics || !metricsError && isMetricsEnabled();
 		const loggingUp = !loggingError;
 		const allUp = tracingUp && metricsUp && loggingUp;
-		const anyDown = features.tracing && tracingError || features.metrics && metricsError || loggingError;
+		const allDown = (!tracingUp || !features.tracing) && (!metricsUp || !features.metrics) && !loggingUp;
+		let status = "healthy";
+		if (!allUp) status = allDown ? "unhealthy" : "degraded";
 		return {
-			status: allUp ? "healthy" : anyDown ? "degraded" : "unhealthy",
+			status,
 			timestamp: new Date().toISOString(),
 			service: serviceName,
 			version: serviceVersion,
@@ -1134,43 +971,43 @@ function createFoundation(input) {
 		tracer: tracerInstance,
 		meter: meterInstance,
 		getTracer: (name) => {
-			warnDeprecation("getTracer", "observability.getTracer");
+			warnDeprecation("getTracer", "observability.getTracer", logger);
 			return observability.getTracer(name);
 		},
 		getMeter: (name, version) => {
-			warnDeprecation("getMeter", "observability.getMeter");
+			warnDeprecation("getMeter", "observability.getMeter", logger);
 			return observability.getMeter(name, version);
 		},
 		getTraceContext: () => {
-			warnDeprecation("getTraceContext", "observability.getTraceContext");
+			warnDeprecation("getTraceContext", "observability.getTraceContext", logger);
 			return observability.getTraceContext();
 		},
 		getActiveSpan: () => {
-			warnDeprecation("getActiveSpan", "observability.getActiveSpan");
+			warnDeprecation("getActiveSpan", "observability.getActiveSpan", logger);
 			return observability.getActiveSpan();
 		},
 		createHttpClient: (options) => {
-			warnDeprecation("createHttpClient", "http.createClient");
+			warnDeprecation("createHttpClient", "http.createClient", logger);
 			return httpModule.createClient(options);
 		},
 		shutdown: () => {
-			warnDeprecation("shutdown", "lifecycle.shutdown");
+			warnDeprecation("shutdown", "lifecycle.shutdown", logger);
 			return lifecycle.shutdown();
 		},
 		isReady: () => {
-			warnDeprecation("isReady", "lifecycle.isReady");
+			warnDeprecation("isReady", "lifecycle.isReady", logger);
 			return lifecycle.isReady();
 		},
 		health: () => {
-			warnDeprecation("health", "lifecycle.health");
+			warnDeprecation("health", "lifecycle.health", logger);
 			return lifecycle.health();
 		},
 		trace: (name, fn) => {
-			warnDeprecation("trace", "observability.trace");
+			warnDeprecation("trace", "observability.trace", logger);
 			return observability.trace(name, fn);
 		},
 		safeRun: (fn, fallback) => {
-			warnDeprecation("safeRun", "lifecycle.safeRun");
+			warnDeprecation("safeRun", "lifecycle.safeRun", logger);
 			return lifecycle.safeRun(fn, fallback);
 		}
 	};
@@ -1181,6 +1018,9 @@ const setupObservability = createFoundation;
 
 //#endregion
 //#region src/integrations/object-store/aws-s3.ts
+function isAwsError(err) {
+	return typeof err === "object" && err !== null;
+}
 async function loadAwsS3() {
 	try {
 		const clientMod = await import("@aws-sdk/client-s3");
@@ -1195,13 +1035,10 @@ async function loadAwsS3() {
 			getSignedUrl: presignerMod.getSignedUrl
 		};
 	} catch (err) {
-		const e = err;
+		const e = err instanceof Error ? err : new Error(String(err));
 		throw new Error(`AWS SDK not available. Install optional peer deps: @aws-sdk/client-s3 and @aws-sdk/s3-request-presigner. Original error: ${e.message}`);
 	}
 }
-function normalizeBody(body) {
-	return body;
-}
 /**
 * AwsS3ObjectStore - wraps AWS S3 behind the provider-agnostic `ObjectStore` interface.
 *
@@ -1230,7 +1067,7 @@ var AwsS3ObjectStore = class {
 		const res = await s3.send(new aws.PutObjectCommand({
 			Bucket: ref.bucket,
 			Key: ref.key,
-			Body: normalizeBody(body),
+			Body: body,
 			ContentType: options.contentType,
 			CacheControl: options.cacheControl,
 			Metadata: options.metadata
@@ -1280,10 +1117,11 @@ var AwsS3ObjectStore = class {
 				lastModified: res.LastModified
 			};
 		} catch (err) {
-			const e = err;
-			const name = String(e?.name || "");
-			const httpStatus = e?.$metadata?.httpStatusCode;
-			if (httpStatus === 404 || name.includes("NotFound") || name.includes("NoSuchKey")) return { exists: false };
+			if (isAwsError(err)) {
+				const name = String(err.name ?? "");
+				const httpStatus = err.$metadata?.httpStatusCode;
+				if (httpStatus === 404 || name.includes("NotFound") || name.includes("NoSuchKey")) return { exists: false };
+			}
 			throw err;
 		}
 	}
@@ -1304,8 +1142,9 @@ var AwsS3ObjectStore = class {
 			ContinuationToken: options.continuationToken,
 			MaxKeys: options.maxKeys
 		}));
+		const contents = res?.Contents ?? [];
 		return {
-			objects: (res?.Contents ?? []).map((o) => ({
+			objects: contents.filter((o) => typeof o.Key === "string").map((o) => ({
 				key: o.Key,
 				size: o.Size,
 				etag: o.ETag,
@@ -1336,19 +1175,31 @@ var AwsS3ObjectStore = class {
 
 //#endregion
 //#region src/integrations/object-store/in-memory.ts
+const DEFAULT_MAX_OBJECTS = 1e4;
+const STREAM_TIMEOUT_MS = 3e4;
 function toBuffer(body) {
 	if (typeof body === "string") return Buffer.from(body);
 	if (Buffer.isBuffer(body)) return body;
 	if (body instanceof Uint8Array) return Buffer.from(body);
 	return new Promise((resolve, reject) => {
 		const chunks = [];
+		const timer = setTimeout(() => {
+			body.destroy(new Error("InMemoryObjectStore: stream read timed out"));
+			reject(new Error("InMemoryObjectStore: stream read timed out"));
+		}, STREAM_TIMEOUT_MS);
 		body.on("data", (chunk) => chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)));
-		body.on("end", () => resolve(Buffer.concat(chunks)));
-		body.on("error", reject);
+		body.on("end", () => {
+			clearTimeout(timer);
+			resolve(Buffer.concat(chunks));
+		});
+		body.on("error", (err) => {
+			clearTimeout(timer);
+			reject(err);
+		});
 	});
 }
-function simpleEtag(buf) {
-	return `mem-${buf.length}-${buf.subarray(0, 8).toString("hex")}`;
+function computeEtag(buf) {
+	return `"${createHash("md5").update(buf).digest("hex")}"`;
 }
 /**
 * InMemoryObjectStore - useful for local dev, unit tests, and as a safe default.
@@ -1357,6 +1208,11 @@ function simpleEtag(buf) {
 var InMemoryObjectStore = class {
 	provider = "in-memory";
 	buckets = new Map();
+	maxObjects;
+	objectCount = 0;
+	constructor(options = {}) {
+		this.maxObjects = options.maxObjects ?? DEFAULT_MAX_OBJECTS;
+	}
 	bucketMap(bucket) {
 		let m = this.buckets.get(bucket);
 		if (!m) {
@@ -1366,16 +1222,20 @@ var InMemoryObjectStore = class {
 		return m;
 	}
 	async putObject(ref, body, options = {}) {
+		const map = this.bucketMap(ref.bucket);
+		const isNew = !map.has(ref.key);
+		if (isNew && this.objectCount >= this.maxObjects) throw new Error(`InMemoryObjectStore: max object limit reached (${this.maxObjects})`);
 		const buf = await toBuffer(body);
 		const obj = {
 			body: buf,
 			contentType: options.contentType,
 			cacheControl: options.cacheControl,
 			metadata: options.metadata,
-			etag: simpleEtag(buf),
+			etag: computeEtag(buf),
 			lastModified: new Date()
 		};
-		this.bucketMap(ref.bucket).set(ref.key, obj);
+		map.set(ref.key, obj);
+		if (isNew) this.objectCount++;
 		return { etag: obj.etag };
 	}
 	async getObject(ref) {
@@ -1407,18 +1267,30 @@ var InMemoryObjectStore = class {
 		};
 	}
 	async deleteObject(ref) {
-		this.bucketMap(ref.bucket).delete(ref.key);
+		const map = this.bucketMap(ref.bucket);
+		if (map.delete(ref.key)) this.objectCount--;
 	}
 	async listObjects(options) {
-		const { bucket, prefix = "" } = options;
+		const { bucket, prefix = "", continuationToken, maxKeys = 1e3 } = options;
 		const map = this.bucketMap(bucket);
-		const objects = [...map.entries()].filter(([key]) => key.startsWith(prefix)).map(([key, obj]) => ({
+		const all = [...map.entries()].filter(([key]) => key.startsWith(prefix)).map(([key, obj]) => ({
 			key,
 			size: obj.body.length,
 			etag: obj.etag,
 			lastModified: obj.lastModified
 		})).sort((a, b) => a.key.localeCompare(b.key));
-		return { objects };
+		let startIndex = 0;
+		if (continuationToken) {
+			const idx = all.findIndex((o) => o.key === continuationToken);
+			if (idx === -1) throw new Error(`InMemoryObjectStore: invalid continuationToken "${continuationToken}"`);
+			startIndex = idx + 1;
+		}
+		const page = all.slice(startIndex, startIndex + maxKeys);
+		const hasMore = startIndex + maxKeys < all.length;
+		return {
+			objects: page,
+			nextContinuationToken: hasMore ? page[page.length - 1]?.key : void 0
+		};
 	}
 	async presignGetObject(_ref, _options) {
 		throw new Error("InMemoryObjectStore does not support presigned URLs");