Files
lolympus-tournament-support/apps/api/src/modules/global/observability/performance-observer.ts
T

282 lines
7.8 KiB
TypeScript

import { AsyncLocalStorage } from 'node:async_hooks';
import { randomUUID } from 'node:crypto';
import { appendFile } from 'node:fs/promises';
import {
addNewRelicCustomAttributes,
NewRelicAttributeValue,
recordNewRelicCustomEvent,
} from './new-relic';
export type PerformanceEventType = 'api-request' | 'mongoose-query';
export interface ApiPerformanceConfig {
enabled: boolean;
localEventsEnabled: boolean;
localEventFile: string;
newRelicRequestEventsEnabled: boolean;
newRelicQueryEventsEnabled: boolean;
appName: string;
nodeEnv: string;
}
export interface MongooseQueryPerformance {
operation: string;
modelName: string;
collectionName?: string;
durationMs: number;
docsReturned: number;
hydratedDocsReturned: number;
lean: boolean;
limit?: number;
skip?: number;
filterKeys?: string;
projectionKeys?: string;
sortKeys?: string;
errorName?: string;
}
export interface ApiRequestPerformanceEvent {
type: 'api-request';
timestamp: string;
requestId: string;
method: string;
route: string;
path: string;
statusCode: number;
durationMs: number;
isError: boolean;
queryCount: number;
mongooseDurationMs: number;
docsReturned: number;
hydratedDocsReturned: number;
leanQueryCount: number;
}
export interface MongooseQueryPerformanceEvent extends MongooseQueryPerformance {
type: 'mongoose-query';
timestamp: string;
requestId?: string;
method?: string;
route?: string;
path?: string;
}
export type ApiPerformanceEvent =
| ApiRequestPerformanceEvent
| MongooseQueryPerformanceEvent;
export interface ApiPerformanceContext {
requestId: string;
method: string;
route: string;
path: string;
queries: MongooseQueryPerformance[];
}
const storage = new AsyncLocalStorage<ApiPerformanceContext>();
export function readBoolean(
value: string | undefined,
defaultValue: boolean,
): boolean {
if (value == null || value.trim() === '') return defaultValue;
return !['0', 'false', 'f', 'no', 'n', 'disabled', 'off'].includes(
value.trim().toLowerCase(),
);
}
export function resolveApiPerformanceConfig(
env: NodeJS.ProcessEnv = process.env,
): ApiPerformanceConfig {
const enabled = readBoolean(env.API_PERF_OBSERVABILITY_ENABLED, false);
return {
enabled,
localEventsEnabled: readBoolean(env.API_PERF_LOCAL_EVENTS_ENABLED, enabled),
localEventFile:
env.API_PERF_LOCAL_EVENT_FILE || '/tmp/lolympus-api-performance.ndjson',
newRelicRequestEventsEnabled: readBoolean(
env.API_PERF_NEW_RELIC_REQUEST_EVENTS_ENABLED,
enabled,
),
newRelicQueryEventsEnabled: readBoolean(
env.API_PERF_NEW_RELIC_QUERY_EVENTS_ENABLED,
false,
),
appName: env.NEW_RELIC_APP_NAME || 'lolympus',
nodeEnv: env.NODE_ENV || 'dev',
};
}
export function isApiPerformanceObservabilityEnabled(): boolean {
return resolveApiPerformanceConfig().enabled;
}
export function createApiPerformanceRequestContext(params: {
method: string;
route: string;
path: string;
}): ApiPerformanceContext {
return {
requestId: randomUUID(),
method: params.method,
route: params.route,
path: params.path,
queries: [],
};
}
export function runWithApiPerformanceContext<T>(
context: ApiPerformanceContext,
callback: () => T,
): T {
return storage.run(context, callback);
}
export function getCurrentApiPerformanceContext():
| ApiPerformanceContext
| undefined {
return storage.getStore();
}
export function recordMongooseQueryPerformance(
query: MongooseQueryPerformance,
): void {
if (!isApiPerformanceObservabilityEnabled()) return;
const config = resolveApiPerformanceConfig();
const context = storage.getStore();
context?.queries.push(query);
const event: MongooseQueryPerformanceEvent = {
...query,
type: 'mongoose-query',
timestamp: new Date().toISOString(),
requestId: context?.requestId,
method: context?.method,
route: context?.route,
path: context?.path,
};
if (config.localEventsEnabled) appendLocalPerformanceEvent(event, config);
if (config.newRelicQueryEventsEnabled) {
recordNewRelicCustomEvent('MongooseQueryPerformance', {
appName: config.appName,
nodeEnv: config.nodeEnv,
requestId: event.requestId,
method: event.method,
route: event.route,
operation: event.operation,
modelName: event.modelName,
collectionName: event.collectionName,
durationMs: event.durationMs,
docsReturned: event.docsReturned,
hydratedDocsReturned: event.hydratedDocsReturned,
lean: event.lean,
limit: event.limit,
skip: event.skip,
errorName: event.errorName,
});
}
}
export function buildApiRequestPerformanceEvent(params: {
context: ApiPerformanceContext;
statusCode: number;
durationMs: number;
isError: boolean;
}): ApiRequestPerformanceEvent {
const queries = params.context.queries;
return {
type: 'api-request',
timestamp: new Date().toISOString(),
requestId: params.context.requestId,
method: params.context.method,
route: params.context.route,
path: params.context.path,
statusCode: params.statusCode,
durationMs: params.durationMs,
isError: params.isError,
queryCount: queries.length,
mongooseDurationMs: sum(queries.map((query) => query.durationMs)),
docsReturned: sum(queries.map((query) => query.docsReturned)),
hydratedDocsReturned: sum(
queries.map((query) => query.hydratedDocsReturned),
),
leanQueryCount: queries.filter((query) => query.lean).length,
};
}
export function recordApiRequestPerformance(
event: ApiRequestPerformanceEvent,
): void {
if (!isApiPerformanceObservabilityEnabled()) return;
const config = resolveApiPerformanceConfig();
if (config.localEventsEnabled) appendLocalPerformanceEvent(event, config);
if (config.newRelicRequestEventsEnabled) {
recordNewRelicCustomEvent('ApiRequestPerformance', {
appName: config.appName,
nodeEnv: config.nodeEnv,
requestId: event.requestId,
method: event.method,
route: event.route,
statusCode: event.statusCode,
durationMs: event.durationMs,
isError: event.isError,
queryCount: event.queryCount,
mongooseDurationMs: event.mongooseDurationMs,
docsReturned: event.docsReturned,
hydratedDocsReturned: event.hydratedDocsReturned,
leanQueryCount: event.leanQueryCount,
});
}
addNewRelicCustomAttributes({
appName: config.appName,
nodeEnv: config.nodeEnv,
'api.request_id': event.requestId,
'api.method': event.method,
'api.route': event.route,
'api.status_code': event.statusCode,
'api.duration_ms': event.durationMs,
'api.is_error': event.isError,
'mongoose.query_count': event.queryCount,
'mongoose.duration_ms': event.mongooseDurationMs,
'mongoose.docs_returned': event.docsReturned,
'mongoose.hydrated_docs_returned': event.hydratedDocsReturned,
'mongoose.lean_query_count': event.leanQueryCount,
});
}
export function appendLocalPerformanceEvent(
event: ApiPerformanceEvent,
config: ApiPerformanceConfig = resolveApiPerformanceConfig(),
): void {
void appendFile(config.localEventFile, `${JSON.stringify(event)}\n`).catch(
() => {
// 관측성 실패가 API 응답을 막아선 안 된다.
},
);
}
export function toNewRelicAttributes(
event: ApiRequestPerformanceEvent,
): Record<string, NewRelicAttributeValue> {
return {
requestId: event.requestId,
method: event.method,
route: event.route,
statusCode: event.statusCode,
durationMs: event.durationMs,
isError: event.isError,
queryCount: event.queryCount,
mongooseDurationMs: event.mongooseDurationMs,
docsReturned: event.docsReturned,
hydratedDocsReturned: event.hydratedDocsReturned,
leanQueryCount: event.leanQueryCount,
};
}
function sum(values: number[]): number {
return values.reduce((acc, value) => acc + value, 0);
}