@directus/api 24.0.1 → 25.0.1

package/dist/app.js

@@ -9,8 +9,8 @@ import { createRequire } from 'node:module';
 import path from 'path';
 import qs from 'qs';
 import { registerAuthProviders } from './auth.js';
-import activityRouter from './controllers/activity.js';
 import accessRouter from './controllers/access.js';
+import activityRouter from './controllers/activity.js';
 import assetsRouter from './controllers/assets.js';
 import authRouter from './controllers/auth.js';
 import collectionsRouter from './controllers/collections.js';
@@ -23,6 +23,7 @@ import flowsRouter from './controllers/flows.js';
 import foldersRouter from './controllers/folders.js';
 import graphqlRouter from './controllers/graphql.js';
 import itemsRouter from './controllers/items.js';
+import metricsRouter from './controllers/metrics.js';
 import notFoundHandler from './controllers/not-found.js';
 import notificationsRouter from './controllers/notifications.js';
 import operationsRouter from './controllers/operations.js';
@@ -43,9 +44,6 @@ import usersRouter from './controllers/users.js';
 import utilsRouter from './controllers/utils.js';
 import versionsRouter from './controllers/versions.js';
 import webhooksRouter from './controllers/webhooks.js';
-import retentionSchedule from './schedules/retention.js';
-import telemetrySchedule from './schedules/telemetry.js';
-import tusSchedule from './schedules/tus.js';
 import { isInstalled, validateDatabaseConnection, validateDatabaseExtensions, validateMigrations, } from './database/index.js';
 import emitter from './emitter.js';
 import { getExtensionManager } from './extensions/index.js';
@@ -60,6 +58,10 @@ import rateLimiterGlobal from './middleware/rate-limiter-global.js';
 import rateLimiter from './middleware/rate-limiter-ip.js';
 import sanitizeQuery from './middleware/sanitize-query.js';
 import schema from './middleware/schema.js';
+import metricsSchedule from './schedules/metrics.js';
+import retentionSchedule from './schedules/retention.js';
+import telemetrySchedule from './schedules/telemetry.js';
+import tusSchedule from './schedules/tus.js';
 import { getConfigFromEnv } from './utils/get-config-from-env.js';
 import { Url } from './utils/url.js';
 import { validateStorage } from './utils/validate-storage.js';
@@ -223,6 +225,9 @@ export default async function createApp() {
     app.use('/flows', flowsRouter);
     app.use('/folders', foldersRouter);
     app.use('/items', itemsRouter);
+    if (env['METRICS_ENABLED'] === true) {
+        app.use('/metrics', metricsRouter);
+    }
     app.use('/notifications', notificationsRouter);
     app.use('/operations', operationsRouter);
     app.use('/panels', panelsRouter);
@@ -251,6 +256,7 @@ export default async function createApp() {
     await retentionSchedule();
     await telemetrySchedule();
     await tusSchedule();
+    await metricsSchedule();
     await emitter.emitInit('app.after', { app });
     return app;
 }

package/dist/auth/drivers/oauth2.js

@@ -19,6 +19,7 @@ import { getConfigFromEnv } from '../../utils/get-config-from-env.js';
 import { getIPFromReq } from '../../utils/get-ip-from-req.js';
 import { getSecret } from '../../utils/get-secret.js';
 import { isLoginRedirectAllowed } from '../../utils/is-login-redirect-allowed.js';
+import { verifyJWT } from '../../utils/jwt.js';
 import { Url } from '../../utils/url.js';
 import { LocalAuthDriver } from './local.js';
 export class OAuth2AuthDriver extends LocalAuthDriver {
@@ -254,9 +255,7 @@ export function createOAuth2AuthRouter(providerName) {
         const logger = useLogger();
         let tokenData;
         try {
-            tokenData = jwt.verify(req.cookies[`oauth2.${providerName}`], getSecret(), {
-                issuer: 'directus',
-            });
+            tokenData = verifyJWT(req.cookies[`oauth2.${providerName}`], getSecret());
         }
         catch (e) {
             logger.warn(e, `[OAuth2] Couldn't verify OAuth2 cookie`);

package/dist/auth/drivers/openid.js

@@ -19,6 +19,7 @@ import { getConfigFromEnv } from '../../utils/get-config-from-env.js';
 import { getIPFromReq } from '../../utils/get-ip-from-req.js';
 import { getSecret } from '../../utils/get-secret.js';
 import { isLoginRedirectAllowed } from '../../utils/is-login-redirect-allowed.js';
+import { verifyJWT } from '../../utils/jwt.js';
 import { Url } from '../../utils/url.js';
 import { LocalAuthDriver } from './local.js';
 export class OpenIDAuthDriver extends LocalAuthDriver {
@@ -306,9 +307,7 @@ export function createOpenIDAuthRouter(providerName) {
         const logger = useLogger();
         let tokenData;
         try {
-            tokenData = jwt.verify(req.cookies[`openid.${providerName}`], getSecret(), {
-                issuer: 'directus',
-            });
+            tokenData = verifyJWT(req.cookies[`openid.${providerName}`], getSecret());
         }
         catch (e) {
             logger.warn(e, `[OpenID] Couldn't verify OpenID cookie`);

package/dist/cache.d.ts

@@ -13,7 +13,7 @@ export declare function clearSystemCache(opts?: {
 }): Promise<void>;
 export declare function setSystemCache(key: string, value: any, ttl?: number): Promise<void>;
 export declare function getSystemCache(key: string): Promise<Record<string, any>>;
-export declare function setLocalSchemaCache(schema: SchemaOverview): Promise<void>;
-export declare function getLocalSchemaCache(): Promise<SchemaOverview | undefined>;
+export declare function setMemorySchemaCache(schema: SchemaOverview): void;
+export declare function getMemorySchemaCache(): Readonly<SchemaOverview> | undefined;
 export declare function setCacheValue(cache: Keyv, key: string, value: Record<string, any> | Record<string, any>[], ttl?: number): Promise<void>;
 export declare function getCacheValue(cache: Keyv, key: string): Promise<any>;

package/dist/cache.js

@@ -9,14 +9,16 @@ import { getConfigFromEnv } from './utils/get-config-from-env.js';
 import { getMilliseconds } from './utils/get-milliseconds.js';
 import { validateEnv } from './utils/validate-env.js';
 import { createRequire } from 'node:module';
+import { freezeSchema, unfreezeSchema } from './utils/freeze-schema.js';
 const logger = useLogger();
 const env = useEnv();
 const require = createRequire(import.meta.url);
 let cache = null;
 let systemCache = null;
-let localSchemaCache = null;
 let lockCache = null;
 let messengerSubscribed = false;
+let localSchemaCache = null;
+let memorySchemaCache = null;
 const messenger = useBus();
 if (redisConfigAvailable() && !messengerSubscribed) {
     messengerSubscribed = true;
@@ -25,6 +27,7 @@ if (redisConfigAvailable() && !messengerSubscribed) {
             await cache.clear();
         }
         await localSchemaCache?.clear();
+        memorySchemaCache = null;
     });
 }
 export function getCache() {
@@ -61,6 +64,7 @@ export async function clearSystemCache(opts) {
         await lockCache.delete('system-cache-lock');
     }
     await localSchemaCache.clear();
+    memorySchemaCache = null;
     // Since a lot of cached permission function rely on the schema it needs to be cleared as well
     await clearPermissionCache();
     messenger.publish('schemaChanged', { autoPurgeCache: opts?.autoPurgeCache });
@@ -75,13 +79,22 @@ export async function getSystemCache(key) {
     const { systemCache } = getCache();
     return await getCacheValue(systemCache, key);
 }
-export async function setLocalSchemaCache(schema) {
-    const { localSchemaCache } = getCache();
-    await localSchemaCache.set('schema', schema);
+export function setMemorySchemaCache(schema) {
+    if (Object.isFrozen(schema)) {
+        memorySchemaCache = schema;
+    }
+    else {
+        memorySchemaCache = freezeSchema(schema);
+    }
 }
-export async function getLocalSchemaCache() {
-    const { localSchemaCache } = getCache();
-    return await localSchemaCache.get('schema');
+export function getMemorySchemaCache() {
+    if (env['CACHE_SCHEMA_FREEZE_ENABLED']) {
+        return memorySchemaCache ?? undefined;
+    }
+    else if (memorySchemaCache) {
+        return unfreezeSchema(memorySchemaCache);
+    }
+    return undefined;
 }
 export async function setCacheValue(cache, key, value, ttl) {
     const compressed = await compress(value);

package/dist/controllers/assets.js

@@ -151,7 +151,7 @@ asyncHandler(async (req, res) => {
             }
         }
     }
-    const { stream, file, stat } = await service.getAsset(id, { transformationParams, acceptFormat }, range);
+    const { stream, file, stat } = await service.getAsset(id, { transformationParams, acceptFormat }, range, true);
     const filename = req.params['filename'] ?? file.filename_download;
     res.attachment(filename);
     res.setHeader('Content-Type', file.type);
@@ -180,7 +180,7 @@ asyncHandler(async (req, res) => {
         res.setHeader('Content-Length', stat.size);
         return res.end();
     }
-    stream
+    (await stream())
         .on('error', (error) => {
         logger.error(error, `Couldn't stream file ${file.id} to the client`);
         if (!res.headersSent) {

package/dist/controllers/metrics.d.ts

@@ -0,0 +1,2 @@
+declare const router: import("express-serve-static-core").Router;
+export default router;

package/dist/controllers/metrics.js

@@ -0,0 +1,33 @@
+import { useEnv } from '@directus/env';
+import { ForbiddenError } from '@directus/errors';
+import { Router } from 'express';
+import { useMetrics } from '../metrics/index.js';
+import asyncHandler from '../utils/async-handler.js';
+const env = useEnv();
+const router = Router();
+const metrics = useMetrics();
+router.get('/', asyncHandler(async (req, _res, next) => {
+    if (req.accountability?.admin === true) {
+        return next();
+    }
+    // support Bearer Token of type `Metrics`
+    const metricTokens = env['METRICS_TOKENS'];
+    if (!req.headers || !req.headers.authorization || !metricTokens) {
+        throw new ForbiddenError();
+    }
+    const parts = req.headers.authorization.split(' ');
+    if (parts.length !== 2 || parts[0].toLowerCase() !== 'metrics') {
+        throw new ForbiddenError();
+    }
+    if (metricTokens.find((mt) => mt.toString() === parts[1]) !== undefined) {
+        return next();
+    }
+    throw new ForbiddenError();
+}), asyncHandler(async (_req, res) => {
+    res.set('Content-Type', 'text/plain');
+    // Don't cache anything by default
+    res.setHeader('Cache-Control', 'no-cache');
+    res.setHeader('Vary', 'Origin, Cache-Control');
+    return res.send(await metrics?.readAll());
+}));
+export default router;

package/dist/controllers/server.js

@@ -1,6 +1,6 @@
+import { RouteNotFoundError } from '@directus/errors';
 import { format } from 'date-fns';
 import { Router } from 'express';
-import { RouteNotFoundError } from '@directus/errors';
 import { respond } from '../middleware/respond.js';
 import { ServerService } from '../services/server.js';
 import { SpecificationService } from '../services/specifications.js';

package/dist/database/helpers/number/dialects/mssql.d.ts

@@ -1,7 +1,7 @@
+import type { NumericValue } from '@directus/types';
 import type { Knex } from 'knex';
 import { NumberDatabaseHelper, type NumberInfo } from '../types.js';
-import type { NumericValue } from '@directus/types';
 export declare class NumberHelperMSSQL extends NumberDatabaseHelper {
-    addSearchCondition(dbQuery: Knex.QueryBuilder, collection: string, name: string, value: NumericValue): Knex.QueryBuilder;
+    addSearchCondition(dbQuery: Knex.QueryBuilder, collection: string, name: string, value: NumericValue, logical: 'and' | 'or'): Knex.QueryBuilder;
     isNumberValid(value: NumericValue, info: NumberInfo): boolean;
 }

package/dist/database/helpers/number/dialects/mssql.js

@@ -1,9 +1,9 @@
+import { NumberDatabaseHelper } from '../types.js';
 import { maybeStringifyBigInt } from '../utils/maybe-stringify-big-int.js';
 import { numberInRange } from '../utils/number-in-range.js';
-import { NumberDatabaseHelper } from '../types.js';
 export class NumberHelperMSSQL extends NumberDatabaseHelper {
-    addSearchCondition(dbQuery, collection, name, value) {
-        return dbQuery.orWhere({ [`${collection}.${name}`]: maybeStringifyBigInt(value) });
+    addSearchCondition(dbQuery, collection, name, value, logical) {
+        return dbQuery[logical].where({ [`${collection}.${name}`]: maybeStringifyBigInt(value) });
     }
     isNumberValid(value, info) {
         return numberInRange(value, info);

package/dist/database/helpers/number/dialects/oracle.d.ts

@@ -1,6 +1,6 @@
+import type { NumericValue } from '@directus/types';
 import type { Knex } from 'knex';
 import { NumberDatabaseHelper } from '../types.js';
-import type { NumericValue } from '@directus/types';
 export declare class NumberHelperOracle extends NumberDatabaseHelper {
-    addSearchCondition(dbQuery: Knex.QueryBuilder, collection: string, name: string, value: NumericValue): Knex.QueryBuilder;
+    addSearchCondition(dbQuery: Knex.QueryBuilder, collection: string, name: string, value: NumericValue, logical: 'and' | 'or'): Knex.QueryBuilder;
 }

package/dist/database/helpers/number/dialects/oracle.js

@@ -1,7 +1,7 @@
 import { NumberDatabaseHelper } from '../types.js';
 import { maybeStringifyBigInt } from '../utils/maybe-stringify-big-int.js';
 export class NumberHelperOracle extends NumberDatabaseHelper {
-    addSearchCondition(dbQuery, collection, name, value) {
-        return dbQuery.orWhere({ [`${collection}.${name}`]: maybeStringifyBigInt(value) });
+    addSearchCondition(dbQuery, collection, name, value, logical) {
+        return dbQuery[logical].where({ [`${collection}.${name}`]: maybeStringifyBigInt(value) });
     }
 }

package/dist/database/helpers/number/dialects/sqlite.d.ts

@@ -1,6 +1,6 @@
+import type { NumericValue } from '@directus/types';
 import type { Knex } from 'knex';
 import { NumberDatabaseHelper } from '../types.js';
-import type { NumericValue } from '@directus/types';
 export declare class NumberHelperSQLite extends NumberDatabaseHelper {
-    addSearchCondition(dbQuery: Knex.QueryBuilder, collection: string, name: string, value: NumericValue): Knex.QueryBuilder;
+    addSearchCondition(dbQuery: Knex.QueryBuilder, collection: string, name: string, value: NumericValue, logical: 'and' | 'or'): Knex.QueryBuilder;
 }

package/dist/database/helpers/number/dialects/sqlite.js

@@ -1,7 +1,7 @@
 import { NumberDatabaseHelper } from '../types.js';
 import { maybeStringifyBigInt } from '../utils/maybe-stringify-big-int.js';
 export class NumberHelperSQLite extends NumberDatabaseHelper {
-    addSearchCondition(dbQuery, collection, name, value) {
-        return dbQuery.orWhere({ [`${collection}.${name}`]: maybeStringifyBigInt(value) });
+    addSearchCondition(dbQuery, collection, name, value, logical) {
+        return dbQuery[logical].where({ [`${collection}.${name}`]: maybeStringifyBigInt(value) });
     }
 }

package/dist/database/helpers/number/types.d.ts

@@ -1,12 +1,12 @@
+import type { NumericType, NumericValue } from '@directus/types';
 import type { Knex } from 'knex';
 import { DatabaseHelper } from '../types.js';
-import type { NumericType, NumericValue } from '@directus/types';
 export type NumberInfo = {
     type: NumericType;
     precision: number | null;
     scale: number | null;
 };
 export declare abstract class NumberDatabaseHelper extends DatabaseHelper {
-    addSearchCondition(dbQuery: Knex.QueryBuilder, collection: string, name: string, value: NumericValue): Knex.QueryBuilder;
+    addSearchCondition(dbQuery: Knex.QueryBuilder, collection: string, name: string, value: NumericValue, logical: 'and' | 'or'): Knex.QueryBuilder;
     isNumberValid(_value: NumericValue, _info: NumberInfo): boolean;
 }

package/dist/database/helpers/number/types.js

@@ -1,7 +1,7 @@
 import { DatabaseHelper } from '../types.js';
 export class NumberDatabaseHelper extends DatabaseHelper {
-    addSearchCondition(dbQuery, collection, name, value) {
-        return dbQuery.orWhere({ [`${collection}.${name}`]: value });
+    addSearchCondition(dbQuery, collection, name, value, logical) {
+        return dbQuery[logical].where({ [`${collection}.${name}`]: value });
     }
     isNumberValid(_value, _info) {
         return true;

package/dist/database/index.js

@@ -11,6 +11,7 @@ import { performance } from 'perf_hooks';
 import { promisify } from 'util';
 import { getExtensionsPath } from '../extensions/lib/get-extensions-path.js';
 import { useLogger } from '../logger/index.js';
+import { useMetrics } from '../metrics/index.js';
 import { getConfigFromEnv } from '../utils/get-config-from-env.js';
 import { validateEnv } from '../utils/validate-env.js';
 import { getHelpers } from './helpers/index.js';
@@ -25,6 +26,7 @@ export function getDatabase() {
     }
     const env = useEnv();
     const logger = useLogger();
+    const metrics = useMetrics();
     const { client, version, searchPath, connectionString, pool: poolConfig = {}, ...connectionConfig } = getConfigFromEnv('DB_', ['DB_EXCLUDE_TABLES']);
     const requiredEnvVars = ['DB_CLIENT'];
     switch (client) {
@@ -148,6 +150,7 @@ export function getDatabase() {
         if (time) {
             delta = performance.now() - time;
             times.delete(queryInfo.__knexUid);
+            metrics?.getDatabaseResponseMetric()?.observe(delta);
         }
         // eslint-disable-next-line no-nested-ternary
         const bindings = queryInfo.bindings

package/dist/metrics/index.d.ts

@@ -0,0 +1 @@
+export * from './lib/use-metrics.js';

package/dist/metrics/index.js

@@ -0,0 +1 @@
+export * from './lib/use-metrics.js';

package/dist/metrics/lib/create-metrics.d.ts

@@ -0,0 +1,15 @@
+import type { MetricObjectWithValues, MetricValue } from 'prom-client';
+import { Counter, Histogram } from 'prom-client';
+export declare function createMetrics(): {
+    getDatabaseErrorMetric: () => Counter | null;
+    getDatabaseResponseMetric: () => Histogram | null;
+    getCacheErrorMetric: () => Counter | null;
+    getRedisErrorMetric: () => Counter | null;
+    getStorageErrorMetric: (location: string) => Counter | null;
+    aggregate: (data: {
+        pid: number;
+        metrics: MetricObjectWithValues<MetricValue<string>>[];
+    }) => Promise<void>;
+    generate: () => Promise<void>;
+    readAll: () => Promise<string>;
+};

package/dist/metrics/lib/create-metrics.js

@@ -0,0 +1,239 @@
+import { useEnv } from '@directus/env';
+import { toArray } from '@directus/utils';
+import { randomUUID } from 'node:crypto';
+import { Readable } from 'node:stream';
+import { promisify } from 'node:util';
+import pm2 from 'pm2';
+import { AggregatorRegistry, Counter, Histogram, register } from 'prom-client';
+import { getCache } from '../../cache.js';
+import { hasDatabaseConnection } from '../../database/index.js';
+import { redisConfigAvailable, useRedis } from '../../redis/index.js';
+import { getStorage } from '../../storage/index.js';
+const isPM2 = 'PM2_HOME' in process.env;
+const METRICS_SYNC_PACKET = 'directus:metrics---data-sync';
+const listApps = promisify(pm2.list.bind(pm2));
+const sendDataToProcessId = promisify(pm2.sendDataToProcessId.bind(pm2));
+export function createMetrics() {
+    const env = useEnv();
+    const services = env['METRICS_SERVICES'] ?? [];
+    const aggregates = new Map();
+    /**
+     * Listen for PM2 metric data sync messages and add them to the aggregate
+     */
+    if (isPM2) {
+        process.on('message', (packet) => {
+            if (!packet.data || packet.topic !== METRICS_SYNC_PACKET)
+                return;
+            aggregate(packet.data);
+        });
+    }
+    async function generate() {
+        const checkId = randomUUID();
+        await Promise.all([
+            trackDatabaseMetric(),
+            trackCacheMetric(checkId),
+            trackRedisMetric(checkId),
+            trackStorageMetric(checkId),
+        ]);
+        /**
+         * Push generated metrics to all pm2 instances
+         */
+        if (isPM2) {
+            try {
+                const apps = await listApps();
+                const data = await register.getMetricsAsJSON();
+                const syncs = [];
+                for (const app of apps) {
+                    if (app.pm_id === undefined || app.pid === 0 || app.name !== 'directus') {
+                        continue;
+                    }
+                    syncs.push(sendDataToProcessId(app.pm_id, {
+                        data: { pid: process.pid, metrics: data },
+                        topic: METRICS_SYNC_PACKET,
+                    }));
+                }
+                await Promise.allSettled(syncs);
+            }
+            catch {
+                // ignore
+            }
+        }
+    }
+    /**
+     * Add PM2 synced metric to the aggregate store.
+     * Subsequent syncs for the given instance will override previous value.
+     */
+    async function aggregate(data) {
+        aggregates.set(data.pid, data.metrics);
+    }
+    async function readAll() {
+        /**
+         * In a PM2 context we must aggregate the metrics across instances ensuring
+         * only currently active instances are added to the aggregate
+         */
+        if (isPM2 && aggregates.size !== 0) {
+            const apps = await listApps();
+            const aggregate = [];
+            for (const app of apps) {
+                if (aggregates.has(app.pid)) {
+                    aggregate.push(aggregates.get(app.pid));
+                }
+            }
+            if (aggregate.length !== 0) {
+                return AggregatorRegistry.aggregate(aggregate).metrics();
+            }
+        }
+        return register.metrics();
+    }
+    function getDatabaseErrorMetric() {
+        if (services.includes('database') === false) {
+            return null;
+        }
+        const client = env['DB_CLIENT'];
+        let metric = register.getSingleMetric(`directus_db_${client}_connection_errors`);
+        if (!metric) {
+            metric = new Counter({
+                name: `directus_db_${client}_connection_errors`,
+                help: `${client} Database connection error count`,
+            });
+        }
+        return metric;
+    }
+    function getDatabaseResponseMetric() {
+        if (services.includes('database') === false) {
+            return null;
+        }
+        const client = env['DB_CLIENT'];
+        let metric = register.getSingleMetric(`directus_db_${client}_response_time_ms`);
+        if (!metric) {
+            metric = new Histogram({
+                name: `directus_db_${client}_response_time_ms`,
+                help: `${client} Database connection response time`,
+                buckets: [1, 10, 20, 40, 60, 80, 100, 200, 500, 750, 1000],
+            });
+        }
+        return metric;
+    }
+    function getCacheErrorMetric() {
+        if (services.includes('cache') === false || env['CACHE_ENABLED'] !== true) {
+            return null;
+        }
+        if (env['CACHE_STORE'] === 'redis' && redisConfigAvailable() !== true) {
+            return null;
+        }
+        let metric = register.getSingleMetric(`directus_cache_${env['CACHE_STORE']}_connection_errors`);
+        if (!metric) {
+            metric = new Counter({
+                name: `directus_cache_${env['CACHE_STORE']}_connection_errors`,
+                help: 'Cache connection error count',
+            });
+        }
+        return metric;
+    }
+    function getRedisErrorMetric() {
+        if (services.includes('redis') === false || redisConfigAvailable() !== true) {
+            return null;
+        }
+        let metric = register.getSingleMetric('directus_redis_connection_errors');
+        if (!metric) {
+            metric = new Counter({
+                name: `directus_redis_connection_errors`,
+                help: 'Redis connection error count',
+            });
+        }
+        return metric;
+    }
+    function getStorageErrorMetric(location) {
+        if (services.includes('storage') === false) {
+            return null;
+        }
+        let metric = register.getSingleMetric(`directus_storage_${location}_connection_errors`);
+        if (!metric) {
+            metric = new Counter({
+                name: `directus_storage_${location}_connection_errors`,
+                help: `${location} storage connection error count`,
+            });
+        }
+        return metric;
+    }
+    async function trackDatabaseMetric() {
+        const metric = getDatabaseErrorMetric();
+        if (metric === null) {
+            return;
+        }
+        try {
+            if (!(await hasDatabaseConnection())) {
+                metric.inc();
+            }
+        }
+        catch {
+            metric.inc();
+        }
+    }
+    async function trackCacheMetric(checkId) {
+        const metric = getCacheErrorMetric();
+        if (metric === null) {
+            return;
+        }
+        const { cache } = getCache();
+        if (!cache) {
+            return;
+        }
+        try {
+            await cache.set(`metrics-${checkId}`, '1', 5);
+            await cache.delete(`metrics-${checkId}`);
+        }
+        catch {
+            metric.inc();
+        }
+    }
+    async function trackRedisMetric(checkId) {
+        const metric = getRedisErrorMetric();
+        if (metric === null) {
+            return;
+        }
+        const redis = useRedis();
+        try {
+            await redis.set(`metrics-${checkId}`, '1');
+            await redis.del(`metrics-${checkId}`);
+        }
+        catch {
+            metric.inc();
+        }
+    }
+    async function trackStorageMetric(checkId) {
+        if (services.includes('storage') === false) {
+            return;
+        }
+        const storage = await getStorage();
+        for (const location of toArray(env['STORAGE_LOCATIONS'])) {
+            const disk = storage.location(location);
+            const metric = getStorageErrorMetric(location);
+            if (metric === null) {
+                continue;
+            }
+            try {
+                await disk.write(`metric-${checkId}`, Readable.from(['check']));
+                const fileStream = await disk.read(`metric-${checkId}`);
+                await new Promise((resolve) => fileStream.on('data', async () => {
+                    fileStream.destroy();
+                    await disk.delete(`metric-${checkId}`);
+                    return resolve(null);
+                }));
+            }
+            catch {
+                metric.inc();
+            }
+        }
+    }
+    return {
+        getDatabaseErrorMetric,
+        getDatabaseResponseMetric,
+        getCacheErrorMetric,
+        getRedisErrorMetric,
+        getStorageErrorMetric,
+        aggregate,
+        generate,
+        readAll,
+    };
+}

package/dist/metrics/lib/use-metrics.d.ts

@@ -0,0 +1,17 @@
+import { createMetrics } from './create-metrics.js';
+export declare const _cache: {
+    metrics: ReturnType<typeof createMetrics> | undefined;
+};
+export declare const useMetrics: () => {
+    getDatabaseErrorMetric: () => import("prom-client").Counter | null;
+    getDatabaseResponseMetric: () => import("prom-client").Histogram | null;
+    getCacheErrorMetric: () => import("prom-client").Counter | null;
+    getRedisErrorMetric: () => import("prom-client").Counter | null;
+    getStorageErrorMetric: (location: string) => import("prom-client").Counter | null;
+    aggregate: (data: {
+        pid: number;
+        metrics: import("prom-client").MetricObjectWithValues<import("prom-client").MetricValue<string>>[];
+    }) => Promise<void>;
+    generate: () => Promise<void>;
+    readAll: () => Promise<string>;
+} | undefined;

package/dist/metrics/lib/use-metrics.js

@@ -0,0 +1,15 @@
+import { useEnv } from '@directus/env';
+import { toBoolean } from '@directus/utils';
+import { createMetrics } from './create-metrics.js';
+export const _cache = { metrics: undefined };
+export const useMetrics = () => {
+    const env = useEnv();
+    if (!toBoolean(env['METRICS_ENABLED'])) {
+        return;
+    }
+    if (_cache.metrics) {
+        return _cache.metrics;
+    }
+    _cache.metrics = createMetrics();
+    return _cache.metrics;
+};

package/dist/metrics/types/metric.d.ts

@@ -0,0 +1 @@
+export type MetricService = 'database' | 'cache' | 'redis' | 'storage';

package/dist/metrics/types/metric.js

@@ -0,0 +1 @@
+export {};