feat: Replace logging with external library

test/unit/init/BaseUrlVerifier.test.ts

@@ -1,9 +1,9 @@
+import { getLoggerFor } from 'global-logger-factory';
+import type { Logger } from 'global-logger-factory';
 import { BaseUrlVerifier } from '../../../src/init/BaseUrlVerifier';
-import type { Logger } from '../../../src/logging/Logger';
-import { getLoggerFor } from '../../../src/logging/LogUtil';
 import type { KeyValueStorage } from '../../../src/storage/keyvalue/KeyValueStorage';
 
-jest.mock('../../../src/logging/LogUtil', (): any => {
+jest.mock('global-logger-factory', (): any => {
   const logger: Logger = { warn: jest.fn() } as any;
   return { getLoggerFor: (): Logger => logger };
 });

test/unit/init/ContainerInitializer.test.ts

@@ -1,11 +1,11 @@
+import { getLoggerFor } from 'global-logger-factory';
+import type { Logger } from 'global-logger-factory';
 import { ContainerInitializer } from '../../../src/init/ContainerInitializer';
-import type { Logger } from '../../../src/logging/Logger';
-import { getLoggerFor } from '../../../src/logging/LogUtil';
 import type { Resource, ResourcesGenerator } from '../../../src/pods/generate/ResourcesGenerator';
 import type { KeyValueStorage } from '../../../src/storage/keyvalue/KeyValueStorage';
 import type { ResourceStore } from '../../../src/storage/ResourceStore';
 
-jest.mock('../../../src/logging/LogUtil', (): any => {
+jest.mock('global-logger-factory', (): any => {
   const logger: Logger = { warn: jest.fn(), debug: jest.fn(), info: jest.fn() } as any;
   return { getLoggerFor: (): Logger => logger };
 });

test/unit/init/LoggerInitializer.test.ts

@@ -1,8 +1,8 @@
+import type { LoggerFactory } from 'global-logger-factory';
+import { setGlobalLoggerFactory } from 'global-logger-factory';
 import { LoggerInitializer } from '../../../src/init/LoggerInitializer';
-import type { LoggerFactory } from '../../../src/logging/LoggerFactory';
-import { setGlobalLoggerFactory } from '../../../src/logging/LogUtil';
 
-jest.mock('../../../src/logging/LogUtil');
+jest.mock('global-logger-factory');
 
 describe('LoggerInitializer', (): void => {
   const loggerFactory = {} as LoggerFactory;

test/unit/init/ServerInitializer.test.ts

@@ -1,13 +1,13 @@
 import type { Server } from 'node:http';
 import { Server as HttpsServer } from 'node:https';
+import { getLoggerFor } from 'global-logger-factory';
+import type { Logger } from 'global-logger-factory';
 import { ServerInitializer } from '../../../src/init/ServerInitializer';
-import type { Logger } from '../../../src/logging/Logger';
-import { getLoggerFor } from '../../../src/logging/LogUtil';
 import type { HttpServerFactory } from '../../../src/server/HttpServerFactory';
 
 // Mock so we don't create an actual HTTPS server in the test below
 jest.mock('node:https');
-jest.mock('../../../src/logging/LogUtil');
+jest.mock('global-logger-factory');
 
 describe('ServerInitializer', (): void => {
   let logger: jest.Mocked<Logger>;

test/unit/init/cluster/ClusterManager.test.ts

@@ -1,14 +1,15 @@
 import cluster from 'node:cluster';
 import EventEmitter from 'node:events';
 import { cpus } from 'node:os';
+import * as glf from 'global-logger-factory';
 import { ClusterManager } from '../../../../src';
-import * as LogUtil from '../../../../src/logging/LogUtil';
 
 jest.mock('node:cluster');
 jest.mock('node:os', (): any => ({
   ...jest.requireActual('node:os'),
   cpus: jest.fn().mockImplementation((): any => [{}, {}, {}, {}, {}, {}]),
 }));
+jest.mock('global-logger-factory');
 
 const mockWorker = new EventEmitter() as any;
 mockWorker.process = { pid: 666 };
@@ -17,7 +18,7 @@ describe('A ClusterManager', (): void => {
   const emitter = new EventEmitter();
   const mockCluster = jest.requireMock('node:cluster');
   const mockLogger = { info: jest.fn(), warn: jest.fn() };
-  jest.spyOn(LogUtil, 'getLoggerFor').mockImplementation((): any => mockLogger);
+  jest.spyOn(glf, 'getLoggerFor').mockImplementation((): any => mockLogger);
 
   beforeAll((): void => {
     Object.assign(mockCluster, {

test/unit/logging/LazyLoggerFactory.test.ts

@@ -1,93 +0,0 @@
-import { LazyLoggerFactory } from '../../../src/logging/LazyLoggerFactory';
-import type { Logger } from '../../../src/logging/Logger';
-import type { LoggerFactory } from '../../../src/logging/LoggerFactory';
-
-describe('LazyLoggerFactory', (): void => {
-  let lazyLoggerFactory: LazyLoggerFactory;
-  let dummyLoggerFactory: jest.Mocked<LoggerFactory>;
-
-  beforeEach(async(): Promise<void> => {
-    lazyLoggerFactory = new LazyLoggerFactory();
-    dummyLoggerFactory = {
-      createLogger: jest.fn((): jest.Mocked<Logger> => ({
-        log: jest.fn((): any => null),
-      }) as any),
-    } as any;
-  });
-
-  it('does not allow reading the internal factory before it is set.', (): void => {
-    expect((): void => {
-      expect(lazyLoggerFactory.loggerFactory).toBeNull();
-    }).toThrow('Logger factory not yet set.');
-  });
-
-  it('allows setting the internal factory.', (): void => {
-    lazyLoggerFactory.loggerFactory = dummyLoggerFactory;
-    expect(lazyLoggerFactory.loggerFactory).toBe(dummyLoggerFactory);
-  });
-
-  it('creates loggers with the right labels.', (): void => {
-    lazyLoggerFactory.createLogger('LoggerA');
-    lazyLoggerFactory.createLogger('LoggerB');
-
-    lazyLoggerFactory.loggerFactory = dummyLoggerFactory;
-
-    expect(dummyLoggerFactory.createLogger).toHaveBeenCalledTimes(2);
-    expect(dummyLoggerFactory.createLogger).toHaveBeenNthCalledWith(1, 'LoggerA');
-    expect(dummyLoggerFactory.createLogger).toHaveBeenNthCalledWith(2, 'LoggerB');
-
-    lazyLoggerFactory.createLogger('LoggerC');
-    expect(dummyLoggerFactory.createLogger).toHaveBeenCalledTimes(3);
-    expect(dummyLoggerFactory.createLogger).toHaveBeenNthCalledWith(3, 'LoggerC');
-  });
-
-  it('emits logged messages after a logger is set.', (): void => {
-    const loggerA = lazyLoggerFactory.createLogger('LoggerA');
-    const loggerB = lazyLoggerFactory.createLogger('LoggerB');
-    loggerA.warn('message1');
-    loggerB.warn('message2');
-    loggerB.error('message3');
-    loggerA.error('message4');
-
-    lazyLoggerFactory.loggerFactory = dummyLoggerFactory;
-
-    const wrappedA = dummyLoggerFactory.createLogger.mock.results[0].value as jest.Mocked<Logger>;
-    expect(wrappedA.log).toHaveBeenCalledTimes(2);
-    expect(wrappedA.log).toHaveBeenNthCalledWith(1, 'warn', 'message1', expect.any(Object));
-    expect(wrappedA.log).toHaveBeenNthCalledWith(2, 'error', 'message4', expect.any(Object));
-
-    const wrappedB = dummyLoggerFactory.createLogger.mock.results[1].value as jest.Mocked<Logger>;
-    expect(wrappedB.log).toHaveBeenCalledTimes(2);
-    expect(wrappedB.log).toHaveBeenNthCalledWith(1, 'warn', 'message2', expect.any(Object));
-    expect(wrappedB.log).toHaveBeenNthCalledWith(2, 'error', 'message3', expect.any(Object));
-  });
-
-  it('does not store more messages than the buffer limit.', (): void => {
-    lazyLoggerFactory = new LazyLoggerFactory({ bufferSize: 100 });
-    const loggerA = lazyLoggerFactory.createLogger('LoggerA');
-    const loggerB = lazyLoggerFactory.createLogger('LoggerB');
-
-    for (let i = 0; i < 50; i++) {
-      loggerA.info('info');
-    }
-    for (let i = 0; i < 50; i++) {
-      loggerB.info('info');
-    }
-
-    lazyLoggerFactory.loggerFactory = dummyLoggerFactory;
-
-    expect(dummyLoggerFactory.createLogger).toHaveBeenCalledTimes(3);
-    const wrappedA = dummyLoggerFactory.createLogger.mock.results[0].value as jest.Mocked<Logger>;
-    const wrappedB = dummyLoggerFactory.createLogger.mock.results[1].value as jest.Mocked<Logger>;
-    const warningLogger = dummyLoggerFactory.createLogger.mock.results[2].value as jest.Mocked<Logger>;
-
-    expect(wrappedA.log).toHaveBeenCalledTimes(50);
-    expect(wrappedB.log).toHaveBeenCalledTimes(49);
-    expect(warningLogger.log).toHaveBeenCalledTimes(1);
-    expect(warningLogger.log).toHaveBeenCalledWith(
-      'warn',
-      'Memory-buffered logging limit of 100 reached',
-      expect.any(Object),
-    );
-  });
-});

test/unit/logging/LogUtil.test.ts

@@ -1,40 +0,0 @@
-import { getLoggerFor, resetInternalLoggerFactory, setGlobalLoggerFactory } from '../../../src/logging/LogUtil';
-
-let currentFactory: any;
-
-class Dummy {
-  private readonly label = 'dummy';
-}
-
-describe('LogUtil', (): void => {
-  beforeAll((): void => {
-    resetInternalLoggerFactory();
-    resetInternalLoggerFactory({
-      get loggerFactory(): any {
-        return currentFactory;
-      },
-      set loggerFactory(value: any) {
-        currentFactory = value;
-      },
-      createLogger: jest.fn((label: string): any => ({ label })),
-    } as any);
-  });
-
-  it('allows creating a lazy logger for a string label.', async(): Promise<void> => {
-    expect(getLoggerFor('MyLabel')).toEqual({ label: 'MyLabel' });
-  });
-
-  it('allows creating a lazy logger for a class instance.', async(): Promise<void> => {
-    expect(getLoggerFor(new Dummy())).toEqual({ label: 'Dummy' });
-  });
-
-  it('reuses loggers for instances of the same class.', async(): Promise<void> => {
-    expect(getLoggerFor(new Dummy())).toBe(getLoggerFor(new Dummy()));
-  });
-
-  it('allows setting the global logger factory.', async(): Promise<void> => {
-    const factory = {} as any;
-    setGlobalLoggerFactory(factory);
-    expect(currentFactory).toBe(factory);
-  });
-});

test/unit/logging/Logger.test.ts

@@ -1,109 +0,0 @@
-import { BaseLogger, WrappingLogger } from '../../../src/logging/Logger';
-import type { LogMetadata, SimpleLogger } from '../../../src/logging/Logger';
-
-class DummyLogger extends BaseLogger {
-  public log(): this {
-    return this;
-  }
-}
-
-describe('Logger', (): void => {
-  describe('a BaseLogger', (): void => {
-    let logger: BaseLogger;
-    const metadata: LogMetadata = {
-      isPrimary: true,
-      pid: process.pid,
-    };
-
-    beforeEach(async(): Promise<void> => {
-      logger = new DummyLogger();
-      jest.spyOn(logger, 'log').mockImplementation();
-    });
-
-    it('delegates error to log.', async(): Promise<void> => {
-      logger.error('my message');
-      expect(logger.log).toHaveBeenCalledTimes(1);
-      expect(logger.log).toHaveBeenCalledWith('error', 'my message', metadata);
-    });
-
-    it('warn delegates to log.', async(): Promise<void> => {
-      logger.warn('my message');
-      expect(logger.log).toHaveBeenCalledTimes(1);
-      expect(logger.log).toHaveBeenCalledWith('warn', 'my message', metadata);
-    });
-
-    it('info delegates to log.', async(): Promise<void> => {
-      logger.info('my message');
-      expect(logger.log).toHaveBeenCalledTimes(1);
-      expect(logger.log).toHaveBeenCalledWith('info', 'my message', metadata);
-    });
-
-    it('verbose delegates to log.', async(): Promise<void> => {
-      logger.verbose('my message');
-      expect(logger.log).toHaveBeenCalledTimes(1);
-      expect(logger.log).toHaveBeenCalledWith('verbose', 'my message', metadata);
-    });
-
-    it('debug delegates to log.', async(): Promise<void> => {
-      logger.debug('my message');
-      expect(logger.log).toHaveBeenCalledTimes(1);
-      expect(logger.log).toHaveBeenCalledWith('debug', 'my message', metadata);
-    });
-
-    it('silly delegates to log.', async(): Promise<void> => {
-      logger.silly('my message');
-      expect(logger.log).toHaveBeenCalledTimes(1);
-      expect(logger.log).toHaveBeenCalledWith('silly', 'my message', metadata);
-    });
-  });
-
-  describe('a WrappingLogger', (): void => {
-    let logger: SimpleLogger;
-    let wrapper: WrappingLogger;
-    const metadata: LogMetadata = {
-      isPrimary: true,
-      pid: process.pid,
-    };
-
-    beforeEach(async(): Promise<void> => {
-      logger = { log: jest.fn() };
-      wrapper = new WrappingLogger(logger);
-    });
-
-    it('error delegates to the internal logger.', async(): Promise<void> => {
-      wrapper.error('my message');
-      expect(logger.log).toHaveBeenCalledTimes(1);
-      expect(logger.log).toHaveBeenCalledWith('error', 'my message', metadata);
-    });
-
-    it('warn delegates to the internal logger.', async(): Promise<void> => {
-      wrapper.warn('my message');
-      expect(logger.log).toHaveBeenCalledTimes(1);
-      expect(logger.log).toHaveBeenCalledWith('warn', 'my message', metadata);
-    });
-
-    it('info delegates to the internal logger.', async(): Promise<void> => {
-      wrapper.info('my message');
-      expect(logger.log).toHaveBeenCalledTimes(1);
-      expect(logger.log).toHaveBeenCalledWith('info', 'my message', metadata);
-    });
-
-    it('verbose delegates to the internal logger.', async(): Promise<void> => {
-      wrapper.verbose('my message');
-      expect(logger.log).toHaveBeenCalledTimes(1);
-      expect(logger.log).toHaveBeenCalledWith('verbose', 'my message', metadata);
-    });
-
-    it('debug delegates to the internal logger.', async(): Promise<void> => {
-      wrapper.debug('my message');
-      expect(logger.log).toHaveBeenCalledTimes(1);
-      expect(logger.log).toHaveBeenCalledWith('debug', 'my message', metadata);
-    });
-
-    it('silly delegates to the internal logger.', async(): Promise<void> => {
-      wrapper.silly('my message');
-      expect(logger.log).toHaveBeenCalledTimes(1);
-      expect(logger.log).toHaveBeenCalledWith('silly', 'my message', metadata);
-    });
-  });
-});

test/unit/logging/VoidLogger.test.ts

@@ -1,12 +0,0 @@
-import { VoidLogger } from '../../../src/logging/VoidLogger';
-
-describe('VoidLogger', (): void => {
-  let logger: VoidLogger;
-  beforeEach(async(): Promise<void> => {
-    logger = new VoidLogger();
-  });
-
-  it('does nothing when log is invoked.', async(): Promise<void> => {
-    expect(logger.log()).toBe(logger);
-  });
-});

test/unit/logging/VoidLoggerFactory.test.ts

@@ -1,14 +0,0 @@
-import { VoidLogger } from '../../../src/logging/VoidLogger';
-import { VoidLoggerFactory } from '../../../src/logging/VoidLoggerFactory';
-
-describe('VoidLoggerFactory', (): void => {
-  let factory: VoidLoggerFactory;
-  beforeEach(async(): Promise<void> => {
-    factory = new VoidLoggerFactory();
-  });
-
-  it('creates VoidLoggers.', async(): Promise<void> => {
-    const logger = factory.createLogger('MyLabel');
-    expect(logger).toBeInstanceOf(VoidLogger);
-  });
-});

test/unit/logging/WinstonLogger.test.ts

@@ -1,18 +0,0 @@
-import { WinstonLogger } from '../../../src/logging/WinstonLogger';
-
-describe('WinstonLogger', (): void => {
-  let innerLogger: any;
-  let logger: WinstonLogger;
-  beforeEach(async(): Promise<void> => {
-    innerLogger = {
-      log: jest.fn(),
-    };
-    logger = new WinstonLogger(innerLogger);
-  });
-
-  it('delegates log invocations to the inner logger.', async(): Promise<void> => {
-    expect(logger.log('debug', 'my message', { abc: true })).toBe(logger);
-    expect(innerLogger.log).toHaveBeenCalledTimes(1);
-    expect(innerLogger.log).toHaveBeenCalledWith('debug', 'my message', { abc: true });
-  });
-});

test/unit/logging/WinstonLoggerFactory.test.ts

@@ -1,77 +0,0 @@
-import { PassThrough } from 'node:stream';
-import type { Logger } from 'winston';
-import type * as Transport from 'winston-transport';
-import { WinstonLogger } from '../../../src/logging/WinstonLogger';
-import { WinstonLoggerFactory } from '../../../src/logging/WinstonLoggerFactory';
-
-const now = new Date();
-jest.useFakeTimers();
-jest.setSystemTime(now);
-
-describe('WinstonLoggerFactory', (): void => {
-  let factory: WinstonLoggerFactory;
-  let transport: jest.Mocked<Transport>;
-
-  beforeEach(async(): Promise<void> => {
-    factory = new WinstonLoggerFactory('debug');
-
-    // Create a dummy log transport
-    transport = new PassThrough({ objectMode: true }) as any;
-    jest.spyOn(transport, 'write').mockImplementation();
-    // eslint-disable-next-line jest/prefer-spy-on
-    transport.log = jest.fn();
-  });
-
-  it('creates WinstonLoggers.', async(): Promise<void> => {
-    const logger = factory.createLogger('MyLabel');
-    expect(logger).toBeInstanceOf(WinstonLogger);
-    const innerLogger: Logger = (logger as any).logger;
-    expect(innerLogger.level).toBe('debug');
-    expect(innerLogger.format).toBeTruthy();
-    expect(innerLogger.transports).toHaveLength(1);
-  });
-
-  it('allows WinstonLoggers to be invoked.', async(): Promise<void> => {
-    (factory as any).createTransports = (): any => [ transport ];
-
-    // Create logger, and log
-    const logger = factory.createLogger('MyLabel');
-    logger.log('debug', 'my message');
-
-    expect(transport.write).toHaveBeenCalledTimes(1);
-    // Need to check level like this as it has color tags
-    const { level } = transport.write.mock.calls[0][0];
-    expect(transport.write).toHaveBeenCalledWith({
-      label: 'MyLabel',
-      level,
-      message: 'my message',
-      timestamp: now.toISOString(),
-      metadata: {},
-      [Symbol.for('level')]: 'debug',
-      [Symbol.for('splat')]: [ undefined ],
-      [Symbol.for('message')]: `${now.toISOString()} [MyLabel] {W-???} ${level}: my message`,
-    });
-  });
-
-  it('allows extra metadata when logging to indicate the thread.', async(): Promise<void> => {
-    (factory as any).createTransports = (): any => [ transport ];
-
-    // Create logger, and log
-    const logger = factory.createLogger('MyLabel');
-    logger.log('debug', 'my message', { isPrimary: true, pid: 0 });
-
-    expect(transport.write).toHaveBeenCalledTimes(1);
-    // Need to check level like this as it has color tags
-    const { level } = transport.write.mock.calls[0][0];
-    expect(transport.write).toHaveBeenCalledWith(expect.objectContaining({
-      label: 'MyLabel',
-      level,
-      message: 'my message',
-      timestamp: now.toISOString(),
-      metadata: { isPrimary: true, pid: 0 },
-      [Symbol.for('level')]: 'debug',
-      [Symbol.for('splat')]: [{ isPrimary: true, pid: 0 }],
-      [Symbol.for('message')]: `${now.toISOString()} [MyLabel] {Primary} ${level}: my message`,
-    }));
-  });
-});

test/unit/server/HandlerServerConfigurator.test.ts

@@ -1,13 +1,13 @@
 import { EventEmitter } from 'node:events';
 import type { IncomingMessage, Server, ServerResponse } from 'node:http';
 import { Readable } from 'node:stream';
-import type { Logger } from '../../../src/logging/Logger';
-import { getLoggerFor } from '../../../src/logging/LogUtil';
+import { getLoggerFor } from 'global-logger-factory';
+import type { Logger } from 'global-logger-factory';
 import { HandlerServerConfigurator } from '../../../src/server/HandlerServerConfigurator';
 import type { HttpHandler } from '../../../src/server/HttpHandler';
 import { flushPromises } from '../../util/Util';
 
-jest.mock('../../../src/logging/LogUtil', (): any => {
+jest.mock('global-logger-factory', (): any => {
   const logger: Logger =
     { error: jest.fn(), info: jest.fn() } as any;
   return { getLoggerFor: (): Logger => logger };

test/unit/server/WebSocketServerConfigurator.test.ts

@@ -1,8 +1,8 @@
 import { EventEmitter } from 'node:events';
 import type { Server } from 'node:http';
 import type { WebSocket } from 'ws';
-import type { Logger } from '../../../src/logging/Logger';
-import { getLoggerFor } from '../../../src/logging/LogUtil';
+import { getLoggerFor } from 'global-logger-factory';
+import type { Logger } from 'global-logger-factory';
 import type { HttpRequest } from '../../../src/server/HttpRequest';
 import type { WebSocketHandler } from '../../../src/server/WebSocketHandler';
 import { WebSocketServerConfigurator } from '../../../src/server/WebSocketServerConfigurator';
@@ -16,7 +16,7 @@ jest.mock('ws', (): any => ({
   })),
 }));
 
-jest.mock('../../../src/logging/LogUtil', (): any => {
+jest.mock('global-logger-factory', (): any => {
   const logger: Logger =
     { error: jest.fn(), info: jest.fn() } as any;
   return { getLoggerFor: (): Logger => logger };

test/unit/server/notifications/KeyValueChannelStorage.test.ts

@@ -1,13 +1,13 @@
+import { getLoggerFor } from 'global-logger-factory';
+import type { Logger } from 'global-logger-factory';
 import type { ResourceIdentifier } from '../../../../src/http/representation/ResourceIdentifier';
-import type { Logger } from '../../../../src/logging/Logger';
-import { getLoggerFor } from '../../../../src/logging/LogUtil';
 import { KeyValueChannelStorage } from '../../../../src/server/notifications/KeyValueChannelStorage';
 import type { NotificationChannel } from '../../../../src/server/notifications/NotificationChannel';
 import type { KeyValueStorage } from '../../../../src/storage/keyvalue/KeyValueStorage';
 import type { ReadWriteLocker } from '../../../../src/util/locking/ReadWriteLocker';
 import resetAllMocks = jest.resetAllMocks;
 
-jest.mock('../../../../src/logging/LogUtil', (): any => {
+jest.mock('global-logger-factory', (): any => {
   const logger: Logger = { info: jest.fn(), error: jest.fn() } as any;
   return { getLoggerFor: (): Logger => logger };
 });

test/unit/server/notifications/ListeningActivityHandler.test.ts

@@ -1,8 +1,8 @@
 import { EventEmitter } from 'node:events';
+import { getLoggerFor } from 'global-logger-factory';
+import type { Logger } from 'global-logger-factory';
 import { RepresentationMetadata } from '../../../../src/http/representation/RepresentationMetadata';
 import type { ResourceIdentifier } from '../../../../src/http/representation/ResourceIdentifier';
-import type { Logger } from '../../../../src/logging/Logger';
-import { getLoggerFor } from '../../../../src/logging/LogUtil';
 import type { ActivityEmitter } from '../../../../src/server/notifications/ActivityEmitter';
 import { ListeningActivityHandler } from '../../../../src/server/notifications/ListeningActivityHandler';
 import type { NotificationChannel } from '../../../../src/server/notifications/NotificationChannel';
@@ -13,7 +13,7 @@ import type { NotificationHandler } from '../../../../src/server/notifications/N
 import { AS } from '../../../../src/util/Vocabularies';
 import { flushPromises } from '../../../util/Util';
 
-jest.mock('../../../../src/logging/LogUtil', (): any => {
+jest.mock('global-logger-factory', (): any => {
   const logger: Logger = { error: jest.fn() } as any;
   return { getLoggerFor: (): Logger => logger };
 });

test/unit/server/notifications/NotificationSubscriber.test.ts

@@ -1,3 +1,5 @@
+import { getLoggerFor } from 'global-logger-factory';
+import type { Logger } from 'global-logger-factory';
 import type { CredentialsExtractor } from '../../../../src/authentication/CredentialsExtractor';
 import type { Authorizer } from '../../../../src/authorization/Authorizer';
 import type { PermissionReader } from '../../../../src/authorization/PermissionReader';
@@ -6,8 +8,6 @@ import { AccessMode } from '../../../../src/authorization/permissions/Permission
 import type { Operation } from '../../../../src/http/Operation';
 import { BasicRepresentation } from '../../../../src/http/representation/BasicRepresentation';
 import type { ResourceIdentifier } from '../../../../src/http/representation/ResourceIdentifier';
-import type { Logger } from '../../../../src/logging/Logger';
-import { getLoggerFor } from '../../../../src/logging/LogUtil';
 import type { HttpRequest } from '../../../../src/server/HttpRequest';
 import type { HttpResponse } from '../../../../src/server/HttpResponse';
 import type { NotificationChannel } from '../../../../src/server/notifications/NotificationChannel';
@@ -24,7 +24,7 @@ import { IdentifierMap, IdentifierSetMultiMap } from '../../../../src/util/map/I
 import { readableToString } from '../../../../src/util/StreamUtil';
 import { flushPromises } from '../../../util/Util';
 
-jest.mock('../../../../src/logging/LogUtil', (): any => {
+jest.mock('global-logger-factory', (): any => {
   const logger: Logger =
     { debug: jest.fn(), error: jest.fn() } as any;
   return { getLoggerFor: (): Logger => logger };

test/unit/server/notifications/StreamingHttpChannel2023/StreamingHttpListeningActivityHandler.test.ts

@@ -1,16 +1,16 @@
 import { EventEmitter } from 'node:events';
 import { PassThrough } from 'node:stream';
+import { getLoggerFor } from 'global-logger-factory';
+import type { Logger } from 'global-logger-factory';
 import { RepresentationMetadata } from '../../../../../src/http/representation/RepresentationMetadata';
 import type { ResourceIdentifier } from '../../../../../src/http/representation/ResourceIdentifier';
-import type { Logger } from '../../../../../src/logging/Logger';
-import { getLoggerFor } from '../../../../../src/logging/LogUtil';
 import type { ActivityEmitter } from '../../../../../src/server/notifications/ActivityEmitter';
 import type { NotificationHandler } from '../../../../../src/server/notifications/NotificationHandler';
 import { AS } from '../../../../../src/util/Vocabularies';
 import { flushPromises } from '../../../../util/Util';
 import { StreamingHttpListeningActivityHandler, StreamingHttpMap } from '../../../../../src';
 
-jest.mock('../../../../../src/logging/LogUtil', (): any => {
+jest.mock('global-logger-factory', (): any => {
   const logger: Logger = { error: jest.fn() } as any;
   return { getLoggerFor: (): Logger => logger };
 });

test/unit/server/notifications/StreamingHttpChannel2023/StreamingHttpRequestHandler.test.ts

@@ -1,4 +1,6 @@
 import { PassThrough } from 'node:stream';
+import { getLoggerFor } from 'global-logger-factory';
+import type { Logger } from 'global-logger-factory';
 import type { CredentialsExtractor } from '../../../../../src/authentication/CredentialsExtractor';
 import type { Authorizer } from '../../../../../src/authorization/Authorizer';
 import type { PermissionReader } from '../../../../../src/authorization/PermissionReader';
@@ -10,8 +12,6 @@ import type { NotificationChannel } from '../../../../../src/server/notification
 import type { HttpRequest } from '../../../../../src/server/HttpRequest';
 import type { HttpResponse } from '../../../../../src/server/HttpResponse';
 import { BasicRepresentation } from '../../../../../src/http/representation/BasicRepresentation';
-import type { Logger } from '../../../../../src/logging/Logger';
-import { getLoggerFor } from '../../../../../src/logging/LogUtil';
 
 import {
   StreamingHttpRequestHandler,
@@ -23,7 +23,7 @@ import { flushPromises } from '../../../../util/Util';
 
 import * as GuardedStream from '../../../../../src/util/GuardedStream';
 
-jest.mock('../../../../../src/logging/LogUtil', (): any => {
+jest.mock('global-logger-factory', (): any => {
   const logger: Logger = { error: jest.fn(), debug: jest.fn() } as any;
   return { getLoggerFor: (): Logger => logger };
 });

test/unit/server/notifications/WebHookChannel2023/WebhookChannel2023Type.test.ts

@@ -1,12 +1,12 @@
 import { DataFactory, Store } from 'n3';
+import { getLoggerFor } from 'global-logger-factory';
+import type { Logger } from 'global-logger-factory';
 import {
   AbsolutePathInteractionRoute,
 } from '../../../../../src/identity/interaction/routing/AbsolutePathInteractionRoute';
 import {
   RelativePathInteractionRoute,
 } from '../../../../../src/identity/interaction/routing/RelativePathInteractionRoute';
-import type { Logger } from '../../../../../src/logging/Logger';
-import { getLoggerFor } from '../../../../../src/logging/LogUtil';
 import { CONTEXT_NOTIFICATION } from '../../../../../src/server/notifications/Notification';
 import type { NotificationChannel } from '../../../../../src/server/notifications/NotificationChannel';
 import type { StateHandler } from '../../../../../src/server/notifications/StateHandler';
@@ -22,7 +22,7 @@ import quad = DataFactory.quad;
 import blankNode = DataFactory.blankNode;
 import namedNode = DataFactory.namedNode;
 
-jest.mock('../../../../../src/logging/LogUtil', (): any => {
+jest.mock('global-logger-factory', (): any => {
   const logger: Logger =
     { error: jest.fn() } as any;
   return { getLoggerFor: (): Logger => logger };

test/unit/server/notifications/WebHookChannel2023/WebhookEmitter.test.ts

@@ -1,13 +1,13 @@
 import fetch from 'cross-fetch';
 import { calculateJwkThumbprint, exportJWK, generateKeyPair, importJWK, jwtVerify } from 'jose';
+import { getLoggerFor } from 'global-logger-factory';
+import type { Logger } from 'global-logger-factory';
 import { BasicRepresentation } from '../../../../../src/http/representation/BasicRepresentation';
 import type { Representation } from '../../../../../src/http/representation/Representation';
 import type { AlgJwk, JwkGenerator } from '../../../../../src/identity/configuration/JwkGenerator';
 import {
   AbsolutePathInteractionRoute,
 } from '../../../../../src/identity/interaction/routing/AbsolutePathInteractionRoute';
-import type { Logger } from '../../../../../src/logging/Logger';
-import { getLoggerFor } from '../../../../../src/logging/LogUtil';
 import type { Notification } from '../../../../../src/server/notifications/Notification';
 import type {
   WebhookChannel2023,
@@ -20,7 +20,7 @@ import { NOTIFY } from '../../../../../src/util/Vocabularies';
 
 jest.mock('cross-fetch');
 
-jest.mock('../../../../../src/logging/LogUtil', (): any => {
+jest.mock('global-logger-factory', (): any => {
   const logger: Logger =
     { error: jest.fn(), debug: jest.fn() } as any;
   return { getLoggerFor: (): Logger => logger };

test/unit/util/GuardedStream.test.ts

@@ -1,10 +1,10 @@
 import { Readable } from 'node:stream';
-import type { Logger } from '../../../src/logging/Logger';
-import { getLoggerFor } from '../../../src/logging/LogUtil';
+import { getLoggerFor } from 'global-logger-factory';
+import type { Logger } from 'global-logger-factory';
 import { guardStream, isGuarded } from '../../../src/util/GuardedStream';
 import { readableToString } from '../../../src/util/StreamUtil';
 
-jest.mock('../../../src/logging/LogUtil', (): any => {
+jest.mock('global-logger-factory', (): any => {
   const logger: Logger = { error: jest.fn() } as any;
   return { getLoggerFor: (): Logger => logger };
 });

test/unit/util/StreamUtil.test.ts

@@ -1,8 +1,8 @@
 import { PassThrough, Readable } from 'node:stream';
 import arrayifyStream from 'arrayify-stream';
 import { BlankNode, Literal, NamedNode, Quad, Store } from 'n3';
-import type { Logger } from '../../../src/logging/Logger';
-import { getLoggerFor } from '../../../src/logging/LogUtil';
+import { getLoggerFor } from 'global-logger-factory';
+import type { Logger } from 'global-logger-factory';
 import { isHttpRequest } from '../../../src/server/HttpRequest';
 import {
   getSingleItem,
@@ -15,7 +15,7 @@ import {
 } from '../../../src/util/StreamUtil';
 import { flushPromises } from '../../util/Util';
 
-jest.mock('../../../src/logging/LogUtil', (): any => {
+jest.mock('global-logger-factory', (): any => {
   const logger: Logger = { warn: jest.fn(), log: jest.fn() } as any;
   return { getLoggerFor: (): Logger => logger };
 });

test/unit/util/TimerUtil.test.ts

@@ -1,4 +1,4 @@
-import type { Logger } from '../../../src/logging/Logger';
+import type { Logger } from 'global-logger-factory';
 import { setSafeInterval } from '../../../src/util/TimerUtil';
 import { flushPromises } from '../../util/Util';