@contember/engine-server 1.2.0-alpha.14 → 1.2.0-alpha.16

package/src/bootstrap/Initializer.ts

@@ -1,4 +1,3 @@
-import { Logger } from '@contember/engine-common'
 import { ProjectGroupContainer } from '@contember/engine-http'
 
 export class Initializer {
@@ -7,34 +6,22 @@ export class Initializer {
 	) {}
 
 	public async initialize(): Promise<string[]> {
-		// eslint-disable-next-line no-console
-		const logger = new Logger(console.log)
-		logger.group('\nInitializing tenant database')
-		// todo
 		const groupContainer = await this.projectGroupContainer
-
+		const tenantMigrationsLogger = groupContainer.logger.child()
 		const tenantContainer = groupContainer.tenantContainer
-		await tenantContainer.migrationsRunner.run(logger.write.bind(logger))
-		logger.groupEnd()
+		await tenantContainer.migrationsRunner.run(tenantMigrationsLogger)
 
 		const projects: string[] = []
 
 		const tenantProjects = await tenantContainer.projectManager.getProjects(tenantContainer.databaseContext)
 		for (const { slug: projectSlug } of tenantProjects) {
-			logger.group(`\nUpdating project ${projectSlug}`)
-			const projectContainer = await groupContainer.projectContainerResolver.getProjectContainer(projectSlug, {
-				alias: false,
-				logger,
-			})
+			const projectContainer = await groupContainer.projectContainerResolver.getProjectContainer(projectSlug, { alias: false })
 			if (!projectContainer) {
 				throw new Error()
 			}
 			const project = projectContainer.project
 			projects.push(project.slug)
-			logger.groupEnd()
 		}
-		// eslint-disable-next-line no-console
-		console.log('')
 		return projects
 	}
 }

package/src/config/configSchema.ts

@@ -3,30 +3,33 @@ import { MailerOptions } from '@contember/engine-tenant-api'
 import { upperCaseFirst } from '../utils'
 
 
-export const dbConfigSchema = Typesafe.intersection(
-	Typesafe.object({
-		host: Typesafe.string,
-		port: Typesafe.number,
-		user: Typesafe.string,
-		password: Typesafe.string,
-		database: Typesafe.string,
-	}),
-	Typesafe.partial({
-		ssl: Typesafe.boolean,
-		queryTimeoutMs: Typesafe.number,
-		statementTimeoutMs: Typesafe.number,
-		connectionTimeoutMs: Typesafe.number,
-		pool: Typesafe.partial({
-			maxConnections: Typesafe.number,
-			maxConnecting: Typesafe.number,
-			maxIdle: Typesafe.number,
-			reconnectIntervalMs: Typesafe.number,
-			idleTimeoutMs: Typesafe.number,
-			acquireTimeoutMs: Typesafe.number,
-			maxUses: Typesafe.number,
-			maxAgeMs: Typesafe.number,
-		}),
+const dbConfigRequired = {
+	host: Typesafe.string,
+	port: Typesafe.number,
+	user: Typesafe.string,
+	password: Typesafe.string,
+	database: Typesafe.string,
+}
+const dbConfigOptional = {
+	ssl: Typesafe.boolean,
+	queryTimeoutMs: Typesafe.number,
+	statementTimeoutMs: Typesafe.number,
+	connectionTimeoutMs: Typesafe.number,
+	pool: Typesafe.partial({
+		maxConnections: Typesafe.number,
+		maxConnecting: Typesafe.number,
+		maxIdle: Typesafe.number,
+		reconnectIntervalMs: Typesafe.number,
+		idleTimeoutMs: Typesafe.number,
+		acquireTimeoutMs: Typesafe.number,
+		maxUses: Typesafe.number,
+		maxAgeMs: Typesafe.number,
 	}),
+}
+
+export const dbConfigSchema = Typesafe.intersection(
+	Typesafe.object(dbConfigRequired),
+	Typesafe.partial(dbConfigOptional),
 )
 
 export const tenantConfigSchema = Typesafe.intersection(
@@ -91,6 +94,10 @@ export const stageConfig = Typesafe.record(
 	),
 )
 
+const readDbSchema = Typesafe.intersection(
+	Typesafe.partial(dbConfigRequired),
+	Typesafe.partial(dbConfigOptional),
+)
 export const projectConfigSchema = Typesafe.object({
 	name: Typesafe.union(
 		Typesafe.string,
@@ -107,6 +114,13 @@ export const projectConfigSchema = Typesafe.object({
 		),
 		Typesafe.partial({
 			systemSchema: Typesafe.string,
+			read: (val: unknown) => {
+				const readDb = readDbSchema(val)
+				if ('host' in readDb) {
+					return readDb
+				}
+				return undefined
+			},
 		}),
 	),
 })

package/src/config/configTemplate.ts

@@ -58,6 +58,24 @@ export const configTemplate: any = {
 				maxUses: '%?project.env.DB_POOL_MAX_USES%',
 				maxAgeMs: '%?project.env.DB_POOL_MAX_AGE_MS%',
 			},
+			read: {
+				host: `%?project.env.DB_READ_HOST%`,
+				port: `%?project.env.DB_READ_PORT::number%`,
+				user: `%?project.env.DB_READ_USER%`,
+				password: `%?project.secret.db.read.password||project.env.DB_READ_PASSWORD%`,
+				database: `%?project.env.DB_READ_NAME%`,
+				ssl: `%?project.env.DB_READ_SSL::bool%`,
+				pool: {
+					maxConnections: '%?project.env.DB_READ_POOL_MAX_CONNECTIONS%',
+					maxConnecting: '%?project.env.DB_READ_POOL_MAX_CONNECTING%',
+					maxIdle: '%?project.env.DB_READ_POOL_MAX_IDLE%',
+					reconnectIntervalMs: '%?project.env.DB_READ_POOL_RECONNECT_INTERVAL_MS%',
+					idleTimeoutMs: '%?project.env.DB_READ_POOL_IDLE_TIMEOUT_MS%',
+					acquireTimeoutMs: '%?project.env.DB_READ_POOL_ACQUIRE_TIMEOUT_MS%',
+					maxUses: '%?project.env.DB_READ_POOL_MAX_USES%',
+					maxAgeMs: '%?project.env.DB_READ_POOL_MAX_AGE_MS%',
+				},
+			},
 		},
 	},
 	server: {

package/src/project/ProjectContainer.ts

@@ -10,6 +10,7 @@ import {
 	ProjectContainer,
 	Providers,
 } from '@contember/engine-http'
+import { Logger } from '@contember/logger'
 
 export class ProjectContainerFactoryFactory {
 	constructor(
@@ -19,8 +20,8 @@ export class ProjectContainerFactoryFactory {
 	) {
 	}
 
-	create(schemaVersionBuilder: SchemaVersionBuilder): ProjectContainerFactory {
-		return new ProjectContainerFactory(this.debug, this.plugins, schemaVersionBuilder, this.providers)
+	create(schemaVersionBuilder: SchemaVersionBuilder, logger: Logger): ProjectContainerFactory {
+		return new ProjectContainerFactory(this.debug, this.plugins, schemaVersionBuilder, this.providers, logger)
 	}
 }
 
@@ -34,6 +35,7 @@ export class ProjectContainerFactory {
 		private readonly plugins: Plugin[],
 		private readonly schemaVersionBuilder: SchemaVersionBuilder,
 		private readonly providers: Providers,
+		private readonly logger: Logger,
 	) {}
 
 	public createContainer(args: ProjectContainerFactoryArgs): ProjectContainer {
@@ -42,9 +44,11 @@ export class ProjectContainerFactory {
 			.pick(
 				'project',
 				'connection',
+				'readConnection',
 				'systemDatabaseContextFactory',
 				'contentSchemaResolver',
 				'graphQlSchemaFactory',
+				'logger',
 			)
 	}
 
@@ -54,10 +58,25 @@ export class ProjectContainerFactory {
 				this.providers)
 			.addService('schemaVersionBuilder', () =>
 				this.schemaVersionBuilder)
+			.addService('logger', () =>
+				this.logger.child({ project: project.slug }))
 			.addService('project', () =>
 				project)
-			.addService('connection', ({ project }) =>
-				Connection.create(project.db))
+			.addService('connection', ({ project, logger }) =>
+				Connection.create(project.db, err => logger.error(err)))
+			.addService('readConnection', ({ project, logger, connection }) => {
+				if (!project.db.read) {
+					return connection
+				}
+				return Connection.create({
+					...project.db,
+					...project.db.read,
+					pool: {
+						...project.db.pool,
+						...project.db.read.pool,
+					},
+				}, err => logger.error(err))
+			})
 			.addService('graphQlSchemaBuilderFactory', () =>
 				new GraphQlSchemaBuilderFactory())
 			.addService('permissionsByIdentityFactory', ({}) =>

package/src/project/ProjectContainerResolver.ts

@@ -3,9 +3,9 @@ import { ProjectContainer } from '@contember/engine-http'
 import { DatabaseContext, ProjectManager, ProjectWithSecrets } from '@contember/engine-tenant-api'
 import { ProjectInitializer as SystemProjectInitializer } from '@contember/engine-system-api'
 import { ProjectContainerStore } from './ProjectContainerStore'
-import { Logger } from '@contember/engine-common'
 import { ProjectConfigResolver } from '../config/projectConfigResolver'
 import { TenantConfig } from '../config/config'
+import { Logger } from '@contember/logger'
 
 export class ProjectContainerResolver {
 	private projectContainers = new ProjectContainerStore()
@@ -22,7 +22,7 @@ export class ProjectContainerResolver {
 	) {}
 
 
-	public async getProjectContainer(slug: string, { alias = false, logger }: {alias?: boolean; logger?: Logger} = {}): Promise<ProjectContainer | undefined> {
+	public async getProjectContainer(slug: string, { alias = false }: { alias?: boolean } = {}): Promise<ProjectContainer | undefined> {
 		const realSlug = this.projectContainers.resolveAlias(slug)
 		if (realSlug) {
 			slug = realSlug
@@ -43,7 +43,7 @@ export class ProjectContainerResolver {
 		if (!project) {
 			return undefined
 		}
-		const container = await this.createProjectContainer(project, logger)
+		const container = await this.createProjectContainer(project)
 		if (slug !== project.slug) {
 			this.projectContainers.setAlias(project.slug, slug)
 		}
@@ -59,7 +59,7 @@ export class ProjectContainerResolver {
 			await this.systemProjectInitializer.initialize(
 				projectContainer.systemDatabaseContextFactory,
 				projectContainer.project,
-				logger ?? new Logger(() => null),
+				logger ?? projectContainer.logger,
 			)
 			const cleanups = this.onCreate.map(it => it(projectContainer) || (() => null))
 			return {

package/src/project/ProjectInitializer.ts

@@ -1,12 +1,13 @@
 import { ProjectInitializer as ProjectInitializerInterface, ProjectWithSecrets } from '@contember/engine-tenant-api'
 import { ProjectContainerResolver } from './ProjectContainerResolver'
+import { Logger } from '@contember/logger'
 
 export class ProjectInitializer implements ProjectInitializerInterface {
 	constructor(
 		private readonly projectContainerResolver: ProjectContainerResolver,
 	) {}
 
-	async initializeProject(project: ProjectWithSecrets) {
+	async initializeProject(project: ProjectWithSecrets, logger: Logger) {
 		await this.projectContainerResolver.createProjectContainer(project)
 	}
 }
@@ -18,10 +19,10 @@ export class ProjectInitializerProxy implements ProjectInitializerInterface {
 		this.initializer = initializer
 	}
 
-	initializeProject(project: ProjectWithSecrets) {
+	initializeProject(project: ProjectWithSecrets, logger: Logger) {
 		if (!this.initializer) {
 			throw new Error('Initializer is not set')
 		}
-		return this.initializer.initializeProject(project)
+		return this.initializer.initializeProject(project, logger)
 	}
 }

package/src/project/ProjectSchemaResolver.ts

@@ -1,14 +1,10 @@
 import { ProjectSchemaResolver as ProjectSchemaResolverInterface } from '@contember/engine-tenant-api'
-import { SchemaVersionBuilder, VersionedSchema } from '@contember/engine-system-api'
 import { ProjectContainerResolver } from '@contember/engine-http'
 import { Schema } from '@contember/schema'
 
 export class ProjectSchemaResolver implements ProjectSchemaResolverInterface {
-	private schemaCache = new Map<string, VersionedSchema>()
-
 	constructor(
 		private readonly projectContainerResolver: ProjectContainerResolver,
-		private readonly schemaVersionBuilder: SchemaVersionBuilder,
 	) {}
 
 	async getSchema(slug: string) {
@@ -17,16 +13,7 @@ export class ProjectSchemaResolver implements ProjectSchemaResolverInterface {
 			return undefined
 		}
 		const db = container.systemDatabaseContextFactory.create()
-		const cachedSchema = this.schemaCache.get(slug)
-		const newSchema = await this.schemaVersionBuilder.buildSchema(db, cachedSchema)
-		if (cachedSchema !== newSchema) {
-			this.schemaCache.set(slug, newSchema)
-		}
-		return newSchema
-	}
-
-	clearCache() {
-		this.schemaCache.clear()
+		return container.contentSchemaResolver.getSchema(db)
 	}
 }
 
@@ -43,8 +30,4 @@ export class ProjectSchemaResolverProxy implements ProjectSchemaResolverInterfac
 		}
 		return this.resolver.getSchema(projectSlug)
 	}
-
-	clearCache() {
-		this.resolver?.clearCache()
-	}
 }

package/src/projectGroup/ProjectGroupContainer.ts

@@ -23,6 +23,7 @@ import {
 import { SystemContainerFactory } from '@contember/engine-system-api'
 import { ProjectConfigResolver } from '../config/projectConfigResolver'
 import { createSecretKey } from 'crypto'
+import { Logger } from '@contember/logger'
 
 interface ProjectGroupContainerFactoryArgs
 {
@@ -40,18 +41,21 @@ export class ProjectGroupContainerFactory {
 		private readonly projectConfigResolver: ProjectConfigResolver,
 		private readonly tenantGraphQLHandlerFactory: TenantGraphQLHandlerFactory,
 		private readonly systemGraphQLHandlerFactory: SystemGraphQLHandlerFactory,
+		private readonly logger: Logger,
 	) {}
 
 	public create({ config, slug }: ProjectGroupContainerFactoryArgs): ProjectGroupContainer {
 		return new Builder({})
 			.addService('slug', () =>
 				slug)
+			.addService('logger', ({ slug }) =>
+				this.logger.child({ projectGroup: slug }))
 			.addService('providers', () =>
 				this.providers)
 			.addService('tenantDbCredentials', () =>
 				config.db)
-			.addService('tenantConnection', ({ tenantDbCredentials }): Connection.ConnectionType =>
-				Connection.create(tenantDbCredentials))
+			.addService('tenantConnection', ({ tenantDbCredentials, logger }): Connection.ConnectionType =>
+				Connection.create(tenantDbCredentials, err => logger.error(err)))
 			.addService('projectSchemaResolver', () =>
 				new ProjectSchemaResolverProxy())
 			.addService('projectInitializer', () =>
@@ -83,8 +87,8 @@ export class ProjectGroupContainerFactory {
 				this.systemContainerFactory.create({ identityFetcher }))
 			.addService('schemaVersionBuilder', ({ systemContainer }) =>
 				systemContainer.schemaVersionBuilder)
-			.addService('projectContainerFactory', ({  schemaVersionBuilder }) =>
-				this.projectContainerFactoryFactory.create(schemaVersionBuilder))
+			.addService('projectContainerFactory', ({  schemaVersionBuilder, logger }) =>
+				this.projectContainerFactoryFactory.create(schemaVersionBuilder, logger))
 			.addService('tenantProjectManager', ({ tenantContainer }) =>
 				tenantContainer.projectManager)
 			.addService('projectContainerResolver', ({ projectContainerFactory, tenantProjectManager, systemContainer, tenantContainer }) =>
@@ -97,8 +101,8 @@ export class ProjectGroupContainerFactory {
 					config,
 				))
 
-			.setupService('projectSchemaResolver', (it, { projectContainerResolver, schemaVersionBuilder }) => {
-				it.setResolver(new ProjectSchemaResolver(projectContainerResolver, schemaVersionBuilder))
+			.setupService('projectSchemaResolver', (it, { projectContainerResolver }) => {
+				it.setResolver(new ProjectSchemaResolver(projectContainerResolver))
 			})
 			.setupService('projectInitializer', (it, { projectContainerResolver }) => {
 				it.setInitializer(new ProjectInitializer(projectContainerResolver))
@@ -124,6 +128,7 @@ export class ProjectGroupContainerFactory {
 				'projectMembershipResolver',
 				'tenantGraphQLHandler',
 				'slug',
+				'logger',
 			)
 	}
 }

package/src/start.ts

@@ -1,28 +1,37 @@
 #!/usr/bin/env node
 
-import { createContainer, listenOnProcessTermination, serverConfigSchema, TerminationJob } from './index'
+import {
+	createContainer,
+	createDefaultLogger, createSentryLoggerHandler,
+	listenOnProcessTermination,
+	serverConfigSchema,
+	TerminationJob,
+} from './index'
 import loadPlugins from './loadPlugins'
-import { initSentry } from './utils'
-
-
 import { getServerVersion, isDebugMode, printStartInfo, resolveServerConfig } from './utils/serverStartup'
 
-(async () => {
+const logger = createDefaultLogger()
+process.on('warning', message => {
+	logger.warn(message)
+})
+;(async () => {
+	const isDebug = isDebugMode()
 	if (process.env.NODE_HEAPDUMP === 'true') {
-		// eslint-disable-next-line no-console
-		console.log('Initializing heapdump')
+		logger.info('Initializing heapdump')
 		await import('heapdump')
 	}
 	const terminationJobs: TerminationJob[] = []
-	listenOnProcessTermination(terminationJobs)
+	listenOnProcessTermination(terminationJobs, logger)
 
-	const isDebug = isDebugMode()
 	const version = getServerVersion()
-	printStartInfo({ version, isDebug })
+	printStartInfo({ version, isDebug }, logger)
 	const plugins = await loadPlugins()
 	const { serverConfig, projectConfigResolver, tenantConfigResolver } = await resolveServerConfig({ plugins, serverConfigSchema })
 
-	initSentry(serverConfig.logging.sentry?.dsn)
+	const sentryTransport = createSentryLoggerHandler(serverConfig.logging.sentry?.dsn)
+	if (sentryTransport !== null) {
+		logger.addHandler(sentryTransport)
+	}
 
 	const container = createContainer({
 		debugMode: isDebug,
@@ -31,19 +40,17 @@ import { getServerVersion, isDebugMode, printStartInfo, resolveServerConfig } fr
 		tenantConfigResolver,
 		plugins,
 		version,
+		logger,
 	})
 
 	const initializedProjects: string[] = await container.initializer.initialize()
 
 	const httpServer = container.koa.listen(serverConfig.port, () => {
-		// eslint-disable-next-line no-console
-		console.log(`Contember API running on http://localhost:${(serverConfig.port)}`)
-		// eslint-disable-next-line no-console
-		console.log(initializedProjects.length ? `Initialized projects: ${initializedProjects.join(', ')}` : 'No project initialized')
+		logger.info(`Contember API running on http://localhost:${(serverConfig.port)}`)
+		logger.info(initializedProjects.length ? `Initialized projects: ${initializedProjects.join(', ')}` : 'No project initialized')
 	})
 	terminationJobs.push(() => new Promise<any>(resolve => httpServer.close(resolve)))
 })().catch(e => {
-	// eslint-disable-next-line no-console
-	console.log(e)
+	logger.crit(e)
 	process.exit(1)
 })

package/src/tsconfig.json

@@ -55,6 +55,9 @@
 		{
 			"path": "../../engine-vimeo-plugin/src"
 		},
+		{
+			"path": "../../logger/src"
+		},
 		{
 			"path": "../../typesafe/src"
 		}

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)
 		})
 	}