282 lines
7.8 KiB
TypeScript
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);
|
|
}
|