drizzle-multitenant 1.2.0 → 1.3.0

package/dist/metrics/index.d.ts

@@ -0,0 +1,530 @@
+import { l as MetricsResult, i as HealthCheckResult, T as TenantManager } from '../types-CGqsPe2Q.js';
+import { RequestHandler } from 'express';
+import { FastifyInstance, FastifyRequest, FastifyReply } from 'fastify';
+import 'pg';
+import 'drizzle-orm/node-postgres';
+
+/**
+ * Metrics module types
+ * @module drizzle-multitenant/metrics
+ */
+
+/**
+ * Prometheus metric types
+ */
+type PrometheusMetricType = 'gauge' | 'counter' | 'histogram' | 'summary';
+/**
+ * A single Prometheus metric definition
+ */
+interface PrometheusMetric {
+    /** Metric name (e.g., drizzle_pool_connections_total) */
+    name: string;
+    /** Metric help description */
+    help: string;
+    /** Metric type */
+    type: PrometheusMetricType;
+    /** Label names */
+    labels?: string[] | undefined;
+    /** Values with label sets */
+    values: PrometheusMetricValue[];
+}
+/**
+ * A metric value with optional labels
+ */
+interface PrometheusMetricValue {
+    /** Label values (in same order as labels array) */
+    labels?: Record<string, string>;
+    /** Metric value */
+    value: number;
+    /** Optional timestamp in milliseconds */
+    timestamp?: number;
+}
+/**
+ * Options for the Prometheus exporter
+ */
+interface PrometheusExporterOptions {
+    /** Prefix for all metric names (default: drizzle_multitenant) */
+    prefix?: string | undefined;
+    /** Include tenant labels (default: true) */
+    includeTenantLabels?: boolean | undefined;
+    /** Include timestamps in output (default: false) */
+    includeTimestamps?: boolean | undefined;
+    /** Custom labels to add to all metrics */
+    defaultLabels?: Record<string, string> | undefined;
+}
+/**
+ * Aggregated metrics from all sources
+ */
+interface AggregatedMetrics {
+    /** Pool manager metrics */
+    pools: MetricsResult;
+    /** Health check results (optional) */
+    health?: HealthCheckResult | undefined;
+    /** Migration metrics (optional) */
+    migrations?: MigrationMetrics | undefined;
+    /** Timestamp of collection */
+    collectedAt: string;
+}
+/**
+ * Migration metrics for monitoring
+ */
+interface MigrationMetrics {
+    /** Total tenants */
+    totalTenants: number;
+    /** Tenants with pending migrations */
+    tenantsWithPending: number;
+    /** Total pending migrations across all tenants */
+    totalPendingMigrations: number;
+    /** Total applied migrations across all tenants */
+    totalAppliedMigrations: number;
+    /** Tenants in error state */
+    tenantsInError: number;
+    /** Last migration timestamp */
+    lastMigrationAt?: string;
+    /** Per-tenant migration status */
+    perTenant?: TenantMigrationMetric[];
+}
+/**
+ * Per-tenant migration metrics
+ */
+interface TenantMigrationMetric {
+    /** Tenant ID */
+    tenantId: string;
+    /** Number of applied migrations */
+    appliedCount: number;
+    /** Number of pending migrations */
+    pendingCount: number;
+    /** Migration status */
+    status: 'ok' | 'behind' | 'error';
+}
+/**
+ * Metric definitions registry
+ */
+interface MetricDefinition {
+    /** Metric name (without prefix) */
+    name: string;
+    /** Help description */
+    help: string;
+    /** Metric type */
+    type: PrometheusMetricType;
+    /** Label names */
+    labels?: string[];
+    /** Extractor function to get values from aggregated metrics */
+    extract: (metrics: AggregatedMetrics) => PrometheusMetricValue[];
+}
+/**
+ * JSON output for metrics CLI command
+ */
+interface MetricsJsonOutput {
+    /** Pool metrics */
+    pools: {
+        total: number;
+        maxPools: number;
+        tenants: Array<{
+            tenantId: string;
+            schemaName: string;
+            connections: {
+                total: number;
+                idle: number;
+                waiting: number;
+            };
+            lastAccessedAt: string;
+        }>;
+    };
+    /** Shared database metrics */
+    shared: {
+        initialized: boolean;
+        connections: {
+            total: number;
+            idle: number;
+            waiting: number;
+        } | null;
+    };
+    /** Health status */
+    health?: {
+        healthy: boolean;
+        totalPools: number;
+        degradedPools: number;
+        unhealthyPools: number;
+        sharedDbStatus: string;
+        pools: Array<{
+            tenantId: string;
+            status: string;
+            responseTimeMs?: number;
+        }>;
+    };
+    /** Summary statistics */
+    summary: {
+        activePools: number;
+        totalConnections: number;
+        idleConnections: number;
+        waitingRequests: number;
+        healthyPools: number;
+        degradedPools: number;
+        unhealthyPools: number;
+    };
+    /** Collection timestamp */
+    timestamp: string;
+    /** Collection duration */
+    durationMs: number;
+}
+/**
+ * Options for metrics collection
+ */
+interface MetricsCollectorOptions {
+    /** Include health check (default: false, can be slow) */
+    includeHealth?: boolean;
+    /** Health check ping timeout in ms (default: 5000) */
+    healthPingTimeoutMs?: number;
+    /** Include migration status (requires migrator) */
+    includeMigrations?: boolean;
+    /** Specific tenant IDs to check */
+    tenantIds?: string[];
+}
+/**
+ * Framework integration options
+ */
+interface MetricsEndpointOptions extends PrometheusExporterOptions {
+    /** Endpoint path (default: /metrics) */
+    path?: string;
+    /** Enable basic auth */
+    auth?: {
+        username: string;
+        password: string;
+    };
+    /** Include runtime metrics (Node.js memory, CPU, etc.) */
+    includeRuntime?: boolean;
+}
+/**
+ * Runtime metrics for Node.js process
+ */
+interface RuntimeMetrics {
+    /** Process uptime in seconds */
+    uptimeSeconds: number;
+    /** Memory usage in bytes */
+    memoryUsage: {
+        heapTotal: number;
+        heapUsed: number;
+        external: number;
+        rss: number;
+    };
+    /** Event loop lag in milliseconds (if available) */
+    eventLoopLag?: number;
+    /** Active handles count */
+    activeHandles: number;
+    /** Active requests count */
+    activeRequests: number;
+}
+
+/**
+ * Metrics collector that aggregates data from all sources
+ * @module drizzle-multitenant/metrics
+ */
+
+/**
+ * Collects and aggregates metrics from pool manager and other sources
+ *
+ * @example
+ * ```typescript
+ * import { MetricsCollector } from 'drizzle-multitenant/metrics';
+ *
+ * const collector = new MetricsCollector(tenantManager);
+ *
+ * // Quick collection (no health check)
+ * const metrics = await collector.collect();
+ *
+ * // With health check
+ * const fullMetrics = await collector.collect({ includeHealth: true });
+ * ```
+ */
+declare class MetricsCollector<TTenantSchema extends Record<string, unknown> = Record<string, unknown>, TSharedSchema extends Record<string, unknown> = Record<string, unknown>> {
+    private readonly tenantManager;
+    constructor(tenantManager: TenantManager<TTenantSchema, TSharedSchema>);
+    /**
+     * Collect metrics from all sources
+     *
+     * @param options - Collection options
+     * @returns Aggregated metrics from all sources
+     *
+     * @example
+     * ```typescript
+     * // Quick collection
+     * const metrics = await collector.collect();
+     *
+     * // With health check (can be slow for many tenants)
+     * const metrics = await collector.collect({ includeHealth: true });
+     *
+     * // Check specific tenants only
+     * const metrics = await collector.collect({
+     *   includeHealth: true,
+     *   tenantIds: ['tenant-1', 'tenant-2'],
+     * });
+     * ```
+     */
+    collect(options?: MetricsCollectorOptions): Promise<AggregatedMetrics>;
+    /**
+     * Get pool metrics only (synchronous, zero overhead)
+     *
+     * @returns Pool metrics
+     */
+    getPoolMetrics(): MetricsResult;
+    /**
+     * Get health check results
+     *
+     * @param options - Health check options
+     * @returns Health check results
+     */
+    getHealthMetrics(options?: {
+        pingTimeoutMs?: number;
+        tenantIds?: string[];
+    }): Promise<HealthCheckResult>;
+    /**
+     * Get Node.js runtime metrics
+     *
+     * @returns Runtime metrics (memory, uptime, etc.)
+     */
+    getRuntimeMetrics(): RuntimeMetrics;
+    /**
+     * Calculate summary statistics from metrics
+     *
+     * @param metrics - Aggregated metrics
+     * @returns Summary statistics
+     */
+    calculateSummary(metrics: AggregatedMetrics): {
+        activePools: number;
+        totalConnections: number;
+        idleConnections: number;
+        waitingRequests: number;
+        healthyPools: number;
+        degradedPools: number;
+        unhealthyPools: number;
+    };
+}
+/**
+ * Create a metrics collector instance
+ *
+ * @param tenantManager - The tenant manager to collect metrics from
+ * @returns A new MetricsCollector instance
+ *
+ * @example
+ * ```typescript
+ * import { createMetricsCollector } from 'drizzle-multitenant/metrics';
+ *
+ * const collector = createMetricsCollector(tenantManager);
+ * const metrics = await collector.collect({ includeHealth: true });
+ * ```
+ */
+declare function createMetricsCollector<TTenantSchema extends Record<string, unknown> = Record<string, unknown>, TSharedSchema extends Record<string, unknown> = Record<string, unknown>>(tenantManager: TenantManager<TTenantSchema, TSharedSchema>): MetricsCollector<TTenantSchema, TSharedSchema>;
+
+/**
+ * Prometheus metrics exporter
+ * @module drizzle-multitenant/metrics
+ *
+ * Exports metrics in Prometheus text exposition format.
+ * Compatible with Prometheus, Grafana, and other monitoring tools.
+ */
+
+/**
+ * Prometheus metrics exporter
+ *
+ * Converts aggregated metrics to Prometheus text exposition format.
+ *
+ * @example
+ * ```typescript
+ * import { PrometheusExporter, createMetricsCollector } from 'drizzle-multitenant/metrics';
+ *
+ * const collector = createMetricsCollector(tenantManager);
+ * const exporter = new PrometheusExporter({ prefix: 'myapp' });
+ *
+ * // Get metrics
+ * const metrics = await collector.collect({ includeHealth: true });
+ *
+ * // Export as Prometheus text format
+ * const text = exporter.export(metrics);
+ *
+ * // Use in Express endpoint
+ * app.get('/metrics', async (req, res) => {
+ *   const metrics = await collector.collect({ includeHealth: true });
+ *   res.set('Content-Type', 'text/plain; version=0.0.4');
+ *   res.send(exporter.export(metrics));
+ * });
+ * ```
+ */
+declare class PrometheusExporter {
+    private readonly prefix;
+    private readonly includeTenantLabels;
+    private readonly includeTimestamps;
+    private readonly defaultLabels;
+    constructor(options?: PrometheusExporterOptions);
+    /**
+     * Export aggregated metrics to Prometheus text format
+     *
+     * @param metrics - Aggregated metrics from collector
+     * @param runtime - Optional runtime metrics
+     * @returns Prometheus text exposition format string
+     */
+    export(metrics: AggregatedMetrics, runtime?: RuntimeMetrics): string;
+    /**
+     * Convert aggregated metrics to Prometheus metric objects
+     */
+    toPrometheusMetrics(metrics: AggregatedMetrics): PrometheusMetric[];
+    /**
+     * Extract runtime metrics
+     */
+    private extractRuntimeMetrics;
+    /**
+     * Format a single metric in Prometheus text format
+     */
+    private formatMetric;
+    /**
+     * Format labels for Prometheus
+     */
+    private formatLabels;
+    /**
+     * Escape label values for Prometheus
+     */
+    private escapeLabel;
+    /**
+     * Get the content type header for Prometheus
+     */
+    static get contentType(): string;
+}
+/**
+ * Create a Prometheus exporter instance
+ *
+ * @param options - Exporter options
+ * @returns A new PrometheusExporter instance
+ *
+ * @example
+ * ```typescript
+ * import { createPrometheusExporter } from 'drizzle-multitenant/metrics';
+ *
+ * const exporter = createPrometheusExporter({
+ *   prefix: 'myapp',
+ *   defaultLabels: { env: 'production' },
+ * });
+ * ```
+ */
+declare function createPrometheusExporter(options?: PrometheusExporterOptions): PrometheusExporter;
+
+/**
+ * Express metrics endpoint middleware
+ * @module drizzle-multitenant/metrics
+ */
+
+/**
+ * Create an Express middleware that exposes Prometheus metrics
+ *
+ * @param tenantManager - The tenant manager to collect metrics from
+ * @param options - Endpoint configuration options
+ * @returns Express request handler
+ *
+ * @example
+ * ```typescript
+ * import express from 'express';
+ * import { createTenantManager } from 'drizzle-multitenant';
+ * import { createMetricsMiddleware } from 'drizzle-multitenant/metrics';
+ *
+ * const app = express();
+ * const manager = createTenantManager(config);
+ *
+ * // Basic usage
+ * app.use('/metrics', createMetricsMiddleware(manager));
+ *
+ * // With options
+ * app.use('/metrics', createMetricsMiddleware(manager, {
+ *   prefix: 'myapp',
+ *   includeRuntime: true,
+ *   auth: { username: 'prometheus', password: 'secret' },
+ * }));
+ * ```
+ */
+declare function createMetricsMiddleware<TTenantSchema extends Record<string, unknown> = Record<string, unknown>, TSharedSchema extends Record<string, unknown> = Record<string, unknown>>(tenantManager: TenantManager<TTenantSchema, TSharedSchema>, options?: MetricsEndpointOptions): RequestHandler;
+/**
+ * Create an Express route handler for metrics (alternative to middleware)
+ *
+ * @param tenantManager - The tenant manager to collect metrics from
+ * @param options - Endpoint configuration options
+ * @returns Express request handler
+ *
+ * @example
+ * ```typescript
+ * import express from 'express';
+ * import { createMetricsHandler } from 'drizzle-multitenant/metrics';
+ *
+ * const app = express();
+ *
+ * // Mount at any path
+ * app.get('/api/metrics', createMetricsHandler(manager));
+ * app.get('/health/prometheus', createMetricsHandler(manager, { includeRuntime: true }));
+ * ```
+ */
+declare function createMetricsHandler<TTenantSchema extends Record<string, unknown> = Record<string, unknown>, TSharedSchema extends Record<string, unknown> = Record<string, unknown>>(tenantManager: TenantManager<TTenantSchema, TSharedSchema>, options?: Omit<MetricsEndpointOptions, 'path'>): RequestHandler;
+
+/**
+ * Fastify metrics endpoint plugin
+ * @module drizzle-multitenant/metrics
+ */
+
+/**
+ * Fastify metrics plugin options
+ */
+interface FastifyMetricsPluginOptions<TTenantSchema extends Record<string, unknown> = Record<string, unknown>, TSharedSchema extends Record<string, unknown> = Record<string, unknown>> extends MetricsEndpointOptions {
+    /** Tenant manager to collect metrics from */
+    tenantManager: TenantManager<TTenantSchema, TSharedSchema>;
+}
+/**
+ * Fastify plugin that exposes Prometheus metrics endpoint
+ *
+ * @example
+ * ```typescript
+ * import Fastify from 'fastify';
+ * import { createTenantManager } from 'drizzle-multitenant';
+ * import { fastifyMetricsPlugin } from 'drizzle-multitenant/metrics';
+ *
+ * const fastify = Fastify();
+ * const manager = createTenantManager(config);
+ *
+ * // Register plugin
+ * await fastify.register(fastifyMetricsPlugin, {
+ *   tenantManager: manager,
+ *   path: '/metrics',
+ *   prefix: 'myapp',
+ *   includeRuntime: true,
+ * });
+ * ```
+ */
+declare function metricsPlugin<TTenantSchema extends Record<string, unknown> = Record<string, unknown>, TSharedSchema extends Record<string, unknown> = Record<string, unknown>>(fastify: FastifyInstance, options: FastifyMetricsPluginOptions<TTenantSchema, TSharedSchema>): Promise<void>;
+/**
+ * Fastify metrics plugin (wrapped with fastify-plugin)
+ */
+declare const fastifyMetricsPlugin: typeof metricsPlugin;
+/**
+ * Create a metrics route handler for Fastify
+ *
+ * Alternative to using the plugin, useful when you want more control.
+ *
+ * @param tenantManager - The tenant manager to collect metrics from
+ * @param options - Endpoint configuration options
+ * @returns Route handler function
+ *
+ * @example
+ * ```typescript
+ * import Fastify from 'fastify';
+ * import { createFastifyMetricsHandler } from 'drizzle-multitenant/metrics';
+ *
+ * const fastify = Fastify();
+ * const handler = createFastifyMetricsHandler(manager, { includeRuntime: true });
+ *
+ * fastify.get('/metrics', handler);
+ * ```
+ */
+declare function createFastifyMetricsHandler<TTenantSchema extends Record<string, unknown> = Record<string, unknown>, TSharedSchema extends Record<string, unknown> = Record<string, unknown>>(tenantManager: TenantManager<TTenantSchema, TSharedSchema>, options?: Omit<MetricsEndpointOptions, 'path' | 'auth'>): (request: FastifyRequest, reply: FastifyReply) => Promise<string>;
+declare module 'fastify' {
+    interface FastifyInstance {
+        metricsCollector: MetricsCollector;
+        metricsExporter: PrometheusExporter;
+    }
+}
+
+export { type AggregatedMetrics, type FastifyMetricsPluginOptions, type MetricDefinition, MetricsCollector, type MetricsCollectorOptions, type MetricsEndpointOptions, type MetricsJsonOutput, type MigrationMetrics, PrometheusExporter, type PrometheusExporterOptions, type PrometheusMetric, type PrometheusMetricType, type PrometheusMetricValue, type RuntimeMetrics, type TenantMigrationMetric, createFastifyMetricsHandler, createMetricsCollector, createMetricsHandler, createMetricsMiddleware, createPrometheusExporter, fastifyMetricsPlugin };

package/dist/metrics/index.js

@@ -0,0 +1,3 @@
+var O=Object.create;var S=Object.defineProperty;var H=Object.getOwnPropertyDescriptor;var N=Object.getOwnPropertyNames;var F=Object.getPrototypeOf,A=Object.prototype.hasOwnProperty;var R=(t,e)=>()=>(e||t((e={exports:{}}).exports,e),e.exports);var $=(t,e,a,n)=>{if(e&&typeof e=="object"||typeof e=="function")for(let s of N(e))!A.call(t,s)&&s!==a&&S(t,s,{get:()=>e[s],enumerable:!(n=H(e,s))||n.enumerable});return t};var j=(t,e,a)=>(a=t!=null?O(F(t)):{},$(S(a,"default",{value:t,enumerable:true}),t));var k=R((ie,_)=>{var J=/at\s(?:.*\.)?plugin\s.*\n\s*(.*)/,X=/(\w*(\.\w*)*)\..*/;_.exports=function(e){if(e.name.length>0)return e.name;let a=Error.stackTraceLimit;Error.stackTraceLimit=10;try{throw new Error("anonymous function")}catch(n){return Error.stackTraceLimit=a,v(n.stack)}};function v(t){let e=t.match(J);return e?e[1].split(/[/\\]/).slice(-1)[0].match(X)[1]:"anonymous"}_.exports.extractPluginName=v;});var C=R((ce,E)=>{E.exports=function(e){return e[0]==="@"&&(e=e.slice(1).replace("/","-")),e.replace(/-(.)/g,function(a,n){return n.toUpperCase()})};});var L=R((le,x)=>{var Y=k(),G=C(),K=0;function w(t,e={}){let a=false;if(t.default!==void 0&&(t=t.default),typeof t!="function")throw new TypeError(`fastify-plugin expects a function, instead got a '${typeof t}'`);if(typeof e=="string"&&(e={fastify:e}),typeof e!="object"||Array.isArray(e)||e===null)throw new TypeError("The options object should be an object");if(e.fastify!==void 0&&typeof e.fastify!="string")throw new TypeError(`fastify-plugin expects a version string, instead got '${typeof e.fastify}'`);e.name||(a=true,e.name=Y(t)+"-auto-"+K++),t[Symbol.for("skip-override")]=e.encapsulate!==true,t[Symbol.for("fastify.display-name")]=e.name,t[Symbol.for("plugin-meta")]=e,t.default||(t.default=t);let n=G(e.name);return !a&&!t[n]&&(t[n]=t),t}x.exports=w;x.exports.default=w;x.exports.fastifyPlugin=w;});var p=class{constructor(e){this.tenantManager=e;}async collect(e={}){let{includeHealth:a=false,healthPingTimeoutMs:n=5e3,tenantIds:s}=e,r=this.tenantManager.getMetrics(),o;return a&&(o=await this.tenantManager.healthCheck({ping:true,pingTimeoutMs:n,includeShared:true,...s&&{tenantIds:s}})),{pools:r,health:o,collectedAt:new Date().toISOString()}}getPoolMetrics(){return this.tenantManager.getMetrics()}async getHealthMetrics(e){return this.tenantManager.healthCheck({ping:true,pingTimeoutMs:e?.pingTimeoutMs??5e3,includeShared:true,...e?.tenantIds&&{tenantIds:e.tenantIds}})}getRuntimeMetrics(){let e=process.memoryUsage();return {uptimeSeconds:process.uptime(),memoryUsage:{heapTotal:e.heapTotal,heapUsed:e.heapUsed,external:e.external,rss:e.rss},activeHandles:process._getActiveHandles?.()?.length??0,activeRequests:process._getActiveRequests?.()?.length??0}}calculateSummary(e){let a=e.pools,n=e.health,s=0,r=0,o=0;for(let c of a.pools.tenants)s+=c.connections.total,r+=c.connections.idle,o+=c.connections.waiting;a.shared.connections&&(s+=a.shared.connections.total,r+=a.shared.connections.idle,o+=a.shared.connections.waiting);let i=n?n.pools.filter(c=>c.status==="ok").length:a.pools.total,h=n?.degradedPools??0,u=n?.unhealthyPools??0;return {activePools:a.pools.total,totalConnections:s,idleConnections:r,waitingRequests:o,healthyPools:i,degradedPools:h,unhealthyPools:u}}};function U(t){return new p(t)}var D="drizzle_multitenant",W=[{name:"pools_active",help:"Number of active database pools",type:"gauge",extract:t=>[{value:t.pools.pools.total}]},{name:"pools_max",help:"Maximum number of pools allowed",type:"gauge",extract:t=>[{value:t.pools.pools.maxPools}]},{name:"pool_connections_total",help:"Total connections in pool",type:"gauge",labels:["tenant","schema"],extract:t=>t.pools.pools.tenants.map(e=>({labels:{tenant:e.tenantId,schema:e.schemaName},value:e.connections.total}))},{name:"pool_connections_idle",help:"Idle connections in pool",type:"gauge",labels:["tenant","schema"],extract:t=>t.pools.pools.tenants.map(e=>({labels:{tenant:e.tenantId,schema:e.schemaName},value:e.connections.idle}))},{name:"pool_connections_waiting",help:"Waiting requests in pool queue",type:"gauge",labels:["tenant","schema"],extract:t=>t.pools.pools.tenants.map(e=>({labels:{tenant:e.tenantId,schema:e.schemaName},value:e.connections.waiting}))},{name:"pool_last_access_timestamp",help:"Last access timestamp for pool (unix epoch)",type:"gauge",labels:["tenant","schema"],extract:t=>t.pools.pools.tenants.map(e=>({labels:{tenant:e.tenantId,schema:e.schemaName},value:new Date(e.lastAccessedAt).getTime()/1e3}))},{name:"shared_pool_initialized",help:"Whether shared database pool is initialized (1=yes, 0=no)",type:"gauge",extract:t=>[{value:t.pools.shared.initialized?1:0}]},{name:"shared_pool_connections_total",help:"Total connections in shared pool",type:"gauge",extract:t=>[{value:t.pools.shared.connections?.total??0}]},{name:"shared_pool_connections_idle",help:"Idle connections in shared pool",type:"gauge",extract:t=>[{value:t.pools.shared.connections?.idle??0}]},{name:"shared_pool_connections_waiting",help:"Waiting requests in shared pool queue",type:"gauge",extract:t=>[{value:t.pools.shared.connections?.waiting??0}]},{name:"health_status",help:"Overall health status (1=healthy, 0=unhealthy)",type:"gauge",extract:t=>t.health?[{value:t.health.healthy?1:0}]:[]},{name:"health_pools_total",help:"Total number of pools checked",type:"gauge",extract:t=>t.health?[{value:t.health.totalPools}]:[]},{name:"health_pools_degraded",help:"Number of degraded pools",type:"gauge",extract:t=>t.health?[{value:t.health.degradedPools}]:[]},{name:"health_pools_unhealthy",help:"Number of unhealthy pools",type:"gauge",extract:t=>t.health?[{value:t.health.unhealthyPools}]:[]},{name:"health_check_duration_seconds",help:"Duration of health check in seconds",type:"gauge",extract:t=>t.health?[{value:t.health.durationMs/1e3}]:[]},{name:"pool_health_status",help:"Health status per pool (1=ok, 0.5=degraded, 0=unhealthy)",type:"gauge",labels:["tenant","schema","status"],extract:t=>t.health?.pools.map(e=>({labels:{tenant:e.tenantId,schema:e.schemaName,status:e.status},value:e.status==="ok"?1:e.status==="degraded"?.5:0}))??[]},{name:"pool_response_time_seconds",help:"Pool ping response time in seconds",type:"gauge",labels:["tenant","schema"],extract:t=>t.health?.pools.filter(e=>e.responseTimeMs!==void 0).map(e=>({labels:{tenant:e.tenantId,schema:e.schemaName},value:(e.responseTimeMs??0)/1e3}))??[]},{name:"shared_db_health_status",help:"Shared database health status (1=ok, 0.5=degraded, 0=unhealthy)",type:"gauge",extract:t=>{if(!t.health)return [];let e=t.health.sharedDb;return [{value:e==="ok"?1:e==="degraded"?.5:0}]}},{name:"shared_db_response_time_seconds",help:"Shared database ping response time in seconds",type:"gauge",extract:t=>t.health?.sharedDbResponseTimeMs!==void 0?[{value:t.health.sharedDbResponseTimeMs/1e3}]:[]}],z=[{name:"process_uptime_seconds",help:"Process uptime in seconds",type:"gauge",extract:t=>[{value:t.uptimeSeconds}]},{name:"process_heap_bytes_total",help:"Total heap memory in bytes",type:"gauge",extract:t=>[{value:t.memoryUsage.heapTotal}]},{name:"process_heap_bytes_used",help:"Used heap memory in bytes",type:"gauge",extract:t=>[{value:t.memoryUsage.heapUsed}]},{name:"process_external_bytes",help:"External memory in bytes",type:"gauge",extract:t=>[{value:t.memoryUsage.external}]},{name:"process_rss_bytes",help:"Resident Set Size in bytes",type:"gauge",extract:t=>[{value:t.memoryUsage.rss}]},{name:"process_active_handles",help:"Number of active handles",type:"gauge",extract:t=>[{value:t.activeHandles}]},{name:"process_active_requests",help:"Number of active requests",type:"gauge",extract:t=>[{value:t.activeRequests}]}],l=class{prefix;includeTenantLabels;includeTimestamps;defaultLabels;constructor(e={}){this.prefix=e.prefix??D,this.includeTenantLabels=e.includeTenantLabels??true,this.includeTimestamps=e.includeTimestamps??false,this.defaultLabels=e.defaultLabels??{};}export(e,a){let n=this.toPrometheusMetrics(e),s=[];for(let r of n)s.push(...this.formatMetric(r));if(a){let r=this.extractRuntimeMetrics(a);for(let o of r)s.push(...this.formatMetric(o));}return s.join(`
+`)+`
+`}toPrometheusMetrics(e){let a=[];for(let n of W){let s=n.extract(e);if(s.length===0)continue;let o=(this.includeTenantLabels?s:s.map(i=>{if(!i.labels)return i;let{tenant:h,schema:u,...c}=i.labels;return {...i,labels:Object.keys(c).length>0?c:void 0}})).map(i=>({...i,labels:{...this.defaultLabels,...i.labels}}));a.push({name:`${this.prefix}_${n.name}`,help:n.help,type:n.type,labels:n.labels,values:o});}return a}extractRuntimeMetrics(e){let a=[];for(let n of z){let s=n.extract(e);if(s.length===0)continue;let r=s.map(o=>({...o,labels:{...this.defaultLabels,...o.labels}}));a.push({name:`${this.prefix}_${n.name}`,help:n.help,type:n.type,values:r});}return a}formatMetric(e){let a=[];a.push(`# HELP ${e.name} ${e.help}`),a.push(`# TYPE ${e.name} ${e.type}`);for(let n of e.values){let s=this.formatLabels(n.labels),r=this.includeTimestamps&&n.timestamp?` ${n.timestamp}`:"";a.push(`${e.name}${s} ${n.value}${r}`);}return a}formatLabels(e){return !e||Object.keys(e).length===0?"":`{${Object.entries(e).filter(([,n])=>n!=null).map(([n,s])=>`${n}="${this.escapeLabel(s)}"`).join(",")}}`}escapeLabel(e){return e.replace(/\\/g,"\\\\").replace(/"/g,'\\"').replace(/\n/g,"\\n")}static get contentType(){return "text/plain; version=0.0.4; charset=utf-8"}};function V(t){return new l(t)}function P(t,e={}){let a=new p(t),n=new l({prefix:e.prefix,includeTenantLabels:e.includeTenantLabels,includeTimestamps:e.includeTimestamps,defaultLabels:e.defaultLabels}),{auth:s,includeRuntime:r=false}=e;return async(o,i,h)=>{try{if(s){let d=o.headers.authorization;if(!d||!d.startsWith("Basic ")){i.setHeader("WWW-Authenticate",'Basic realm="Metrics"'),i.status(401).send("Authentication required");return}let T=Buffer.from(d.slice(6),"base64").toString(),[y,m]=T.split(":");if(y!==s.username||m!==s.password){i.status(403).send("Invalid credentials");return}}let u=await a.collect({includeHealth:!0}),c=r?a.getRuntimeMetrics():void 0,f=n.export(u,c);i.setHeader("Content-Type",l.contentType),i.send(f);}catch(u){h(u);}}}function B(t,e={}){return P(t,e)}var q=j(L());async function Q(t,e){let{tenantManager:a,path:n="/metrics",auth:s,includeRuntime:r=false,prefix:o,includeTenantLabels:i,includeTimestamps:h,defaultLabels:u}=e,c=new p(a),f=new l({prefix:o,includeTenantLabels:i,includeTimestamps:h,defaultLabels:u}),d=s?async(y,m)=>{let g=y.headers.authorization;if(!g||!g.startsWith("Basic ")){m.header("WWW-Authenticate",'Basic realm="Metrics"'),m.code(401).send("Authentication required");return}let M=Buffer.from(g.slice(6),"base64").toString(),[b,I]=M.split(":");if(b!==s.username||I!==s.password){m.code(403).send("Invalid credentials");return}}:void 0,T={schema:{description:"Prometheus metrics endpoint",tags:["monitoring"],response:{200:{description:"Prometheus text exposition format",type:"string"}}},...d&&{preHandler:d}};t.get(n,T,async(y,m)=>{let g=await c.collect({includeHealth:true}),M=r?c.getRuntimeMetrics():void 0,b=f.export(g,M);return m.header("Content-Type",l.contentType),b}),t.decorate("metricsCollector",c),t.decorate("metricsExporter",f);}var Z=(0, q.default)(Q,{fastify:">=4.0.0",name:"drizzle-multitenant-metrics"});function ee(t,e={}){let a=new p(t),n=new l({prefix:e.prefix,includeTenantLabels:e.includeTenantLabels,includeTimestamps:e.includeTimestamps,defaultLabels:e.defaultLabels}),{includeRuntime:s=false}=e;return async(r,o)=>{let i=await a.collect({includeHealth:true}),h=s?a.getRuntimeMetrics():void 0,u=n.export(i,h);return o.header("Content-Type",l.contentType),u}}export{p as MetricsCollector,l as PrometheusExporter,ee as createFastifyMetricsHandler,U as createMetricsCollector,B as createMetricsHandler,P as createMetricsMiddleware,V as createPrometheusExporter,Z as fastifyMetricsPlugin};