@contember/engine-server 1.2.0-alpha.15 → 1.2.0-alpha.17

package/src/utils/sentry.ts

@@ -1,46 +1,56 @@
 import * as Sentry from '@sentry/node'
+import { LoggerRequestSymbol } from '@contember/engine-http'
+import { LogEntry, LoggerHandler, LogLevel, LogLevels } from '@contember/logger'
 
-export const initSentry = (dsn?: string) => {
+export class SentryLoggerHandler implements LoggerHandler {
+	constructor(
+		private readonly logLevel: LogLevel,
+	) {
+	}
+
+	getMinLevel(): number {
+		return this.logLevel.value
+	}
+
+	handle(entry: LogEntry) {
+		if (!entry.error || entry.level.value < this.logLevel.value) {
+			return
+		}
+		Sentry.captureException(entry.error, scope => {
+			scope.setTag('project', entry.loggerAttributes.project ?? entry.ownAttributes.project)
+			scope.setTag('module', entry.loggerAttributes.module ?? entry.ownAttributes.module)
+			scope.setLevel('error')
+			scope.setUser({
+				id: entry.loggerAttributes.user ?? entry.ownAttributes.user,
+			})
+			scope.setExtra('requestId', entry.loggerAttributes.requestId)
+
+			scope.addEventProcessor(event => {
+				return {
+					...event,
+					request: {
+						url: entry.loggerAttributes.url ?? entry.ownAttributes.url,
+						data: entry.loggerAttributes[LoggerRequestSymbol]?.body,
+					},
+				}
+			})
+			return scope
+		})
+	}
+
+	close(): void {
+	}
+}
+
+export const createSentryLoggerHandler = (dsn?: string): null | LoggerHandler => {
 	if (!dsn) {
-		return
+		return null
 	}
-	// eslint-disable-next-line no-console
-	console.log(`Intializing sentry with dsn: ${dsn}`)
 	Sentry.init({
 		dsn: dsn,
 		integrations: integrations => {
 			return integrations.filter(integration => integration.name !== 'Console' && integration.name !== 'Http')
 		},
 	})
-}
-
-interface SentryErrorContext {
-	user: string
-	body: string
-	project?: string
-	url: string
-	module: string
-}
-
-export const logSentryError = (error: any, context: SentryErrorContext) => {
-	Sentry.withScope(scope => {
-		if (context.project) {
-			scope.setTag('project', context.project)
-		}
-		scope.setTag('module', context.module)
-		scope.setLevel('error')
-		scope.setUser({
-			id: context.user,
-		})
-		scope.addEventProcessor(event => {
-			return {
-				...event,
-				request: {
-					url: context.url,
-					data: context.body,
-				},
-			}
-		})
-		Sentry.captureException(error)
-	})
+	return new SentryLoggerHandler(LogLevels.warn)
 }

package/src/utils/serverStartup.ts

@@ -2,6 +2,7 @@ import { join } from 'path'
 import { ConfigProcessor, Plugin } from '@contember/engine-plugins'
 import { ConfigSource, readConfig, ServerConfig } from '../config/config'
 import { Type } from '@contember/typesafe'
+import { createLogger, JsonStreamLoggerHandler, Logger, LogLevels, PrettyPrintLoggerHandler } from '@contember/logger'
 
 export const getServerVersion = (): string => {
 	const packageJsonFile = process.env.CONTEMBER_PACKAGE_JSON || join(__dirname, '../../../package.json')
@@ -12,16 +13,12 @@ export const getServerVersion = (): string => {
 
 export const isDebugMode = (): boolean => process.env.NODE_ENV === 'development'
 
-export const printStartInfo = ({ version, isDebug }: { version: string; isDebug: boolean }) => {
-	// eslint-disable-next-line no-console
-	console.log(`Starting Contember ${version}`)
-	// eslint-disable-next-line no-console
-	console.log(`NODE_ENV is set to ${process.env.NODE_ENV}`)
+export const printStartInfo = ({ version, isDebug }: { version: string; isDebug: boolean }, logger: Logger) => {
+	logger.info(`Starting Contember ${version}`)
+	logger.info(`NODE_ENV is set to ${process.env.NODE_ENV}`)
 	if (isDebug) {
-		// eslint-disable-next-line no-console
-		console.log('Starting Contember in debug mode')
-		// eslint-disable-next-line no-console
-		console.log('NEVER USE debug mode in production environment')
+		logger.warn('Starting Contember in debug mode')
+		logger.warn('NEVER USE debug mode in production environment')
 	}
 }
 
@@ -40,3 +37,42 @@ export const resolveServerConfig = async <T extends ServerConfig>({ plugins, ser
 
 	return await readConfig(configSources, configProcessors, serverConfigSchema)
 }
+
+export const createDefaultLogger = (): Logger => {
+	const isDebug = isDebugMode()
+	const loggerType = process.env.CONTEMBER_LOGGER_FORMAT ?? (isDebug ? 'pretty' : 'json')
+	const stream = process.stderr
+	const handler = loggerType === 'pretty'
+		? new PrettyPrintLoggerHandler(stream, {
+			formatters: {
+				pid: () => undefined,
+				loggerId: () => undefined,
+				uri: ({ attributes, chalk }) => {
+					const color = attributes.status === undefined
+						? chalk.cyan
+						: attributes.status < 300
+							? chalk.green
+							: chalk.yellowBright
+					const timeInfo = attributes.totalTimeMs !== undefined ? ` ${attributes.totalTimeMs}ms` : ''
+					const statusInfo = attributes.status !== undefined ? ` [${attributes.status}]` : ''
+					return { line: color(`${attributes.method}${statusInfo} ${attributes.uri}${timeInfo} ${chalk.white.dim('#' + attributes.requestId)}`) }
+				},
+				method: () => undefined,
+				requestId: () => undefined,
+				timeLabel: () => undefined,
+				status: () => undefined,
+				totalTimeMs: () => undefined,
+				events: ({ formattedValue }) => formattedValue === '[]' ? undefined : formattedValue,
+			},
+		})
+		: new JsonStreamLoggerHandler(stream)
+	const logLevel = (process.env.CONTEMBER_LOGGER_LEVEL as keyof typeof LogLevels) ?? 'info'
+	return createLogger(handler, {
+		pid: process.pid,
+		loggerId: Math.random().toString().substring(2),
+	}, {
+		fingerCrossedOptions: {
+			logAlwaysLevel: LogLevels[logLevel],
+		},
+	})
+}

package/src/utils/serverTermination.ts

@@ -1,4 +1,5 @@
 import cluster from 'cluster'
+import { Logger } from '@contember/logger'
 
 const signals = {
 	SIGHUP: 1,
@@ -6,14 +7,12 @@ const signals = {
 	SIGTERM: 15,
 }
 export type TerminationJob = (args: { signal: keyof typeof signals; code: number }) => Promise<void>
-export const listenOnProcessTermination = (jobs: TerminationJob[]) => {
+export const listenOnProcessTermination = (jobs: TerminationJob[], logger: Logger) => {
 	for (const [signal, code] of Object.entries(signals)) {
 		process.on(signal, async () => {
-			// eslint-disable-next-line no-console
-			console.log(`Process ${process.pid} received a ${signal} signal, executing ${jobs.length} termination jobs`)
+			logger.info(`Process ${process.pid} received a ${signal} signal, executing ${jobs.length} termination jobs`)
 			await Promise.allSettled(jobs.map(it => it({ signal: signal as keyof typeof signals, code })))
-			// eslint-disable-next-line no-console
-			console.log(cluster.isMaster ? `All terminated, exiting` : 'All terminated, exiting a worker')
+			logger.info(cluster.isMaster ? `All terminated, exiting` : 'All terminated, exiting a worker')
 			process.exit(128 + code)
 		})
 	}

package/tests/cases/configResolver.test.ts

@@ -0,0 +1,67 @@
+import { assert, it } from 'vitest'
+import { createTenantConfigResolver } from '../../src/config/tenantConfigResolver'
+import { configTemplate } from '../../src/config/configTemplate'
+import { createProjectConfigResolver } from '../../src/config/projectConfigResolver'
+
+const env = {
+	DEFAULT_DB_POOL_IDLE_TIMEOUT_MS: '60000',
+	DEFAULT_DB_POOL_MAX_CONNECTIONS: '1000',
+	DEFAULT_DB_POOL_MAX_CONNECTING: '10',
+	DEFAULT_DB_CONNECTION_TIMEOUT_MS: '5000',
+}
+const tenantConfig = {
+	db: {
+		host: 'c0.cluster-abc.eu-west-1.rds.amazonaws.com',
+		port: 5432,
+		user: 'u_test_e',
+		password: 'PASSWD',
+		database: 'p_test_e',
+		read: { host: 'c0.cluster-ro-abc.eu-west-1.rds.amazonaws.com' },
+	},
+}
+it('resolves tenant config config', () => {
+	const tenantResolver = createTenantConfigResolver(env, configTemplate.tenant)
+	const resolvedTenantConfig = tenantResolver('test', tenantConfig)
+	assert.deepEqual(resolvedTenantConfig, {
+		db: {
+			host: 'c0.cluster-abc.eu-west-1.rds.amazonaws.com',
+			port: 5432,
+			user: 'u_test_e',
+			password: 'PASSWD',
+			database: 'p_test_e',
+			connectionTimeoutMs: 5000,
+			pool: { maxConnections: 1000, maxConnecting: 10, idleTimeoutMs: 60000 },
+			read: { host: 'c0.cluster-ro-abc.eu-west-1.rds.amazonaws.com' },
+		}, mailer: {}, credentials: {}, secrets: {},
+	})
+})
+it('resolves project config config', () => {
+	const tenantResolver = createTenantConfigResolver(env, configTemplate.tenant)
+	const resolvedTenantConfig = tenantResolver('test', tenantConfig)
+
+	const projectConfigResolver = createProjectConfigResolver(env, configTemplate, [])
+	const resolvedProjectConfig = projectConfigResolver('test-p', {
+		db: {
+			useTenantDb: true,
+			systemSchema: 'system_test_e',
+		}, s3: { prefix: 'test-e/test-e' }, stages: { live: { schema: 'content_test_e_live' } },
+	}, {}, resolvedTenantConfig)
+
+	assert.deepEqual(resolvedProjectConfig as any, {
+		name: 'Test p',
+		slug: 'test-p',
+		stages: [{ name: 'Live', slug: 'live', schema: 'content_test_e_live' }],
+		db: {
+			host: 'c0.cluster-abc.eu-west-1.rds.amazonaws.com',
+			port: 5432,
+			user: 'u_test_e',
+			password: 'PASSWD',
+			database: 'p_test_e',
+			connectionTimeoutMs: 5000,
+			pool: { maxConnections: 1000, maxConnecting: 10, idleTimeoutMs: 60000 },
+			read: { host: 'c0.cluster-ro-abc.eu-west-1.rds.amazonaws.com' },
+			useTenantDb: true,
+			systemSchema: 'system_test_e',
+		},
+	})
+})