@ngworker/lumberjack
Version:
Lumberjack is a versatile Angular logging library, specifically designed to be extended and customized
262 lines • 31.3 kB
JavaScript
import { inject, Injectable } from '@angular/core';
import { formatLogDriverError } from '../formatting/format-log-driver-error';
import { LumberjackLogFormatter } from '../formatting/lumberjack-log-formatter.service';
import { LumberjackLogDriverLogger } from '../log-drivers/lumberjack-log-driver-logger';
import { lumberjackLogDriverToken } from '../log-drivers/lumberjack-log-driver.token';
import { LumberjackTimeService } from '../time/lumberjack-time.service';
import * as i0 from "@angular/core";
const noReportedLogDriverErrorIndex = -1;
/**
* Service with programmatic API to pass logs to Lumberjack. Optionally
* supports a log payload.
*
* Lumberjack passes the logs to the registered log drivers based on their
* configurations.
*
* NOTE! Consider extending the `LumberjackLogger` or `ScopedLumberjackLogger`
* base classes to set up predefined loggers unless you need a programmatic
* API.
*/
export class LumberjackService {
/**
* The registered log drivers.
*/
#drivers = inject(lumberjackLogDriverToken, { optional: true }) ?? [];
#driverLogger = inject(LumberjackLogDriverLogger);
#logFormatter = inject(LumberjackLogFormatter);
#time = inject(LumberjackTimeService);
constructor() {
this.#drivers = Array.isArray(this.#drivers) ? this.#drivers : [this.#drivers];
}
/**
* Pass a log to Lumberjack which will be forwarded to the registered log
* drivers based on their configurations.
*
* NOTE! It's recommended to use `LumberjackLogBuilder` to create the log.
*
* @param lumberjackLog The Lumberjack log. Optionally supports a log payload.
*/
log(lumberjackLog) {
const { log, formattedLog } = this.#logFormatter.formatLog(lumberjackLog);
this.#logWithErrorHandling(log, formattedLog, this.#drivers);
}
/**
* Pass a critical log to Lumberjack which will be forwarded to the registered
* log drivers based on their configurations.
*
* @param message Log message, for example describing an event that happened.
* @param payload An optional payload to add to the log.
* @param scope An optional scope to add to the {@link LumberjackLog}.
*/
logCritical(message, payload, scope) {
this.log({
createdAt: this.#time.getUnixEpochTicks(),
level: 'critical',
message,
payload,
scope,
});
}
/**
* Pass an error log to Lumberjack which will be forwarded to the registered
* log drivers based on their configurations.
*
* @param message Log message, for example describing an event that happened.
* @param payload An optional payload to add to the log.
* @param scope An optional scope to add to the {@link LumberjackLog}.
*/
logError(message, payload, scope) {
this.log({
createdAt: this.#time.getUnixEpochTicks(),
level: 'error',
message,
payload,
scope,
});
}
/**
* Pass a warning log to Lumberjack which will be forwarded to the registered
* log drivers based on their configurations.
*
* @param message Log message, for example describing an event that happened.
* @param payload An optional payload to add to the log.
* @param scope An optional scope to add to the {@link LumberjackLog}.
*/
logWarning(message, payload, scope) {
this.log({
createdAt: this.#time.getUnixEpochTicks(),
level: 'warn',
message,
payload,
scope,
});
}
/**
* Pass an info log to Lumberjack which will be forwarded to the registered
* log drivers based on their configurations.
*
* @param message Log message, for example describing an event that happened.
* @param payload An optional payload to add to the log.
* @param scope An optional scope to add to the {@link LumberjackLog}.
*/
logInfo(message, payload, scope) {
this.log({
createdAt: this.#time.getUnixEpochTicks(),
level: 'info',
message,
payload,
scope,
});
}
/**
* Pass a debug log to Lumberjack which will be forwarded to the registered
* log drivers based on their configurations.
*
* @param message Log message, for example describing an event that happened.
* @param payload An optional payload to add to the log.
* @param scope An optional scope to add to the {@link LumberjackLog}.
*/
logDebug(message, payload, scope) {
this.log({
createdAt: this.#time.getUnixEpochTicks(),
level: 'debug',
message,
payload,
scope,
});
}
/**
* Pass a trace log to Lumberjack which will be forwarded to the registered
* log drivers based on their configurations.
*
* @param message Log message, for example describing an event that happened.
* @param payload An optional payload to add to the log.
* @param scope An optional scope to add to the {@link LumberjackLog}.
*/
logTrace(message, payload, scope) {
this.log({
createdAt: this.#time.getUnixEpochTicks(),
level: 'trace',
message,
payload,
scope,
});
}
/**
* Determine whether a log driver is configured to accept a log with the
* specified log level.
*
* @param driver The configured log driver.
* @param logLevel The log's log level.
*/
#canDriveLog(driver, logLevel) {
const hasVerboseLogging = driver.config.levels.length === 1 && driver.config.levels[0] === 'verbose';
const acceptsLogLevel = driver.config.levels.includes(logLevel);
return hasVerboseLogging || acceptsLogLevel;
}
/**
* Create a log based on the specified log driver error.
*
* @param driverError The reported log driver error.
*/
#createDriverErrorLog(driverError) {
return {
createdAt: this.#time.getUnixEpochTicks(),
level: 'error',
message: formatLogDriverError(driverError),
scope: 'LumberjackLogDriverError',
};
}
/**
* If any stable log drivers are specified, the log driver errors will be
* forward to them. Otherwise, they will be output to the browser console.
*
* @param stableDrivers The log drivers that haven't failed.
* @param driverErrors The reported log driver errors.
*/
#handleDriverErrors(stableDrivers, driverErrors) {
if (stableDrivers.length > 0) {
this.#logDriverErrorsToStableDrivers(driverErrors, stableDrivers);
}
else {
this.#outputUnhandledDriverErrors(driverErrors);
}
}
/**
* Pass the log to all the specified log drivers filtered by their log driver
* configuration. If the driver throws an error while handling a log, an error
* log with the caught error message will be created and passed to the stable
* log drivers.
*
* @param log The log with an optional log payload.
* @param formattedLog The text representation of the specified log.
* @param drivers The log drivers.
* @param driverErrors The reported log driver errors.
* @param driverErrorIndex Index of the reported driver error to handle.
*/
#logWithErrorHandling(log, formattedLog, drivers, driverErrors = [], driverErrorIndex = noReportedLogDriverErrorIndex) {
const stableDrivers = [];
drivers
.filter((driver) => this.#canDriveLog(driver, log.level))
.forEach((driver) => {
try {
this.#driverLogger.log(driver, { formattedLog, log });
stableDrivers.push(driver);
if (driverErrorIndex !== noReportedLogDriverErrorIndex) {
this.#removeHandledError(driverErrorIndex, driverErrors);
driverErrorIndex = noReportedLogDriverErrorIndex;
}
}
catch (error) {
const caughtDriverError = { error, formattedLog, log, logDriver: driver };
driverErrors = [...driverErrors, caughtDriverError];
}
});
this.#handleDriverErrors(stableDrivers, driverErrors);
}
/**
* Pass the log driver errors to the specified stable log drivers.
*
* @param driverErrors The reported log driver errors.
* @param stableDrivers The log drivers that haven't failed.
*/
#logDriverErrorsToStableDrivers(driverErrors, stableDrivers) {
driverErrors.forEach((error, errorIndex) => {
const driverErrorLog = this.#createDriverErrorLog(error);
this.#logWithErrorHandling(driverErrorLog, driverErrorLog.message, stableDrivers, driverErrors, errorIndex);
});
}
/**
* Output the specified log driver error to the browser console.
*
* @param driverError The reported log driver error.
*/
#outputDriverError(driverError) {
const errorMessage = formatLogDriverError(driverError);
console.error(errorMessage);
}
/**
* Output the unhandled log driver errors to the browser console.
*
* @param driverErrors The reported log driver errors.
*/
#outputUnhandledDriverErrors(driverErrors) {
driverErrors.forEach((error) => this.#outputDriverError(error));
}
/**
* Remove the log driver error with the specified index.
*
* @param driverErrorIndex The index of the log driver error to remove from
* the specified log driver errors.
* @param driverErrors The reported log driver errors.
*/
#removeHandledError(driverErrorIndex, driverErrors) {
driverErrors.splice(driverErrorIndex, 1);
}
static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: LumberjackService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: LumberjackService });
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: LumberjackService, decorators: [{
type: Injectable
}], ctorParameters: () => [] });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lumberjack.service.js","sourceRoot":"","sources":["../../../../../../../packages/ngworker/lumberjack/src/lib/logging/lumberjack.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject, Injectable } from '@angular/core';\n\nimport { formatLogDriverError } from '../formatting/format-log-driver-error';\nimport { LumberjackLogFormatter } from '../formatting/lumberjack-log-formatter.service';\nimport { LumberjackLogDriver } from '../log-drivers/lumberjack-log-driver';\nimport { LumberjackLogDriverError } from '../log-drivers/lumberjack-log-driver-error';\nimport { LumberjackLogDriverLogger } from '../log-drivers/lumberjack-log-driver-logger';\nimport { lumberjackLogDriverToken } from '../log-drivers/lumberjack-log-driver.token';\nimport { LumberjackLogLevel } from '../logs/lumberjack-log-level';\nimport { LumberjackLogPayload } from '../logs/lumberjack-log-payload';\nimport { LumberjackLog } from '../logs/lumberjack.log';\nimport { LumberjackTimeService } from '../time/lumberjack-time.service';\n\nconst noReportedLogDriverErrorIndex = -1;\n\n/**\n * Service with programmatic API to pass logs to Lumberjack. Optionally\n * supports a log payload.\n *\n * Lumberjack passes the logs to the registered log drivers based on their\n * configurations.\n *\n * NOTE! Consider extending the `LumberjackLogger` or `ScopedLumberjackLogger`\n * base classes to set up predefined loggers unless you need a programmatic\n * API.\n */\n@Injectable()\nexport class LumberjackService<TPayload extends LumberjackLogPayload | void = void> {\n  /**\n   * The registered log drivers.\n   */\n  readonly #drivers = inject<LumberjackLogDriver<TPayload>[]>(lumberjackLogDriverToken, { optional: true }) ?? [];\n  readonly #driverLogger = inject<LumberjackLogDriverLogger<TPayload>>(LumberjackLogDriverLogger);\n  readonly #logFormatter = inject<LumberjackLogFormatter<TPayload>>(LumberjackLogFormatter);\n  readonly #time = inject(LumberjackTimeService);\n\n  constructor() {\n    this.#drivers = Array.isArray(this.#drivers) ? this.#drivers : [this.#drivers];\n  }\n\n  /**\n   * Pass a log to Lumberjack which will be forwarded to the registered log\n   * drivers based on their configurations.\n   *\n   * NOTE! It's recommended to use `LumberjackLogBuilder` to create the log.\n   *\n   * @param lumberjackLog The Lumberjack log. Optionally supports a log payload.\n   */\n  log(lumberjackLog: LumberjackLog<TPayload>): void {\n    const { log, formattedLog } = this.#logFormatter.formatLog(lumberjackLog);\n\n    this.#logWithErrorHandling(log, formattedLog, this.#drivers);\n  }\n\n  /**\n   * Pass a critical log to Lumberjack which will be forwarded to the registered\n   * log drivers based on their configurations.\n   *\n   * @param message Log message, for example describing an event that happened.\n   * @param payload An optional payload to add to the log.\n   * @param scope An optional scope to add to the {@link LumberjackLog}.\n   */\n  logCritical(message: string, payload?: TPayload, scope?: string): void {\n    this.log({\n      createdAt: this.#time.getUnixEpochTicks(),\n      level: 'critical',\n      message,\n      payload,\n      scope,\n    });\n  }\n\n  /**\n   * Pass an error log to Lumberjack which will be forwarded to the registered\n   * log drivers based on their configurations.\n   *\n   * @param message Log message, for example describing an event that happened.\n   * @param payload An optional payload to add to the log.\n   * @param scope An optional scope to add to the {@link LumberjackLog}.\n   */\n  logError(message: string, payload?: TPayload, scope?: string): void {\n    this.log({\n      createdAt: this.#time.getUnixEpochTicks(),\n      level: 'error',\n      message,\n      payload,\n      scope,\n    });\n  }\n\n  /**\n   * Pass a warning log to Lumberjack which will be forwarded to the registered\n   * log drivers based on their configurations.\n   *\n   * @param message Log message, for example describing an event that happened.\n   * @param payload An optional payload to add to the log.\n   * @param scope An optional scope to add to the {@link LumberjackLog}.\n   */\n  logWarning(message: string, payload?: TPayload, scope?: string): void {\n    this.log({\n      createdAt: this.#time.getUnixEpochTicks(),\n      level: 'warn',\n      message,\n      payload,\n      scope,\n    });\n  }\n\n  /**\n   * Pass an info log to Lumberjack which will be forwarded to the registered\n   * log drivers based on their configurations.\n   *\n   * @param message Log message, for example describing an event that happened.\n   * @param payload An optional payload to add to the log.\n   * @param scope An optional scope to add to the {@link LumberjackLog}.\n   */\n  logInfo(message: string, payload?: TPayload, scope?: string): void {\n    this.log({\n      createdAt: this.#time.getUnixEpochTicks(),\n      level: 'info',\n      message,\n      payload,\n      scope,\n    });\n  }\n\n  /**\n   * Pass a debug log to Lumberjack which will be forwarded to the registered\n   * log drivers based on their configurations.\n   *\n   * @param message Log message, for example describing an event that happened.\n   * @param payload An optional payload to add to the log.\n   * @param scope An optional scope to add to the {@link LumberjackLog}.\n   */\n  logDebug(message: string, payload?: TPayload, scope?: string): void {\n    this.log({\n      createdAt: this.#time.getUnixEpochTicks(),\n      level: 'debug',\n      message,\n      payload,\n      scope,\n    });\n  }\n\n  /**\n   * Pass a trace log to Lumberjack which will be forwarded to the registered\n   * log drivers based on their configurations.\n   *\n   * @param message Log message, for example describing an event that happened.\n   * @param payload An optional payload to add to the log.\n   * @param scope An optional scope to add to the {@link LumberjackLog}.\n   */\n  logTrace(message: string, payload?: TPayload, scope?: string): void {\n    this.log({\n      createdAt: this.#time.getUnixEpochTicks(),\n      level: 'trace',\n      message,\n      payload,\n      scope,\n    });\n  }\n\n  /**\n   * Determine whether a log driver is configured to accept a log with the\n   * specified log level.\n   *\n   * @param driver The configured log driver.\n   * @param logLevel The log's log level.\n   */\n  #canDriveLog(driver: LumberjackLogDriver<TPayload>, logLevel: LumberjackLogLevel): boolean {\n    const hasVerboseLogging = driver.config.levels.length === 1 && driver.config.levels[0] === 'verbose';\n    const acceptsLogLevel = (driver.config.levels as LumberjackLogLevel[]).includes(logLevel);\n\n    return hasVerboseLogging || acceptsLogLevel;\n  }\n\n  /**\n   * Create a log based on the specified log driver error.\n   *\n   * @param driverError The reported log driver error.\n   */\n  #createDriverErrorLog(driverError: LumberjackLogDriverError<TPayload>): LumberjackLog<TPayload> {\n    return {\n      createdAt: this.#time.getUnixEpochTicks(),\n      level: 'error',\n      message: formatLogDriverError(driverError),\n      scope: 'LumberjackLogDriverError',\n    };\n  }\n\n  /**\n   * If any stable log drivers are specified, the log driver errors will be\n   * forward to them. Otherwise, they will be output to the browser console.\n   *\n   * @param stableDrivers The log drivers that haven't failed.\n   * @param driverErrors The reported log driver errors.\n   */\n  #handleDriverErrors(\n    stableDrivers: LumberjackLogDriver<TPayload>[],\n    driverErrors: LumberjackLogDriverError<TPayload>[]\n  ) {\n    if (stableDrivers.length > 0) {\n      this.#logDriverErrorsToStableDrivers(driverErrors, stableDrivers);\n    } else {\n      this.#outputUnhandledDriverErrors(driverErrors);\n    }\n  }\n\n  /**\n   * Pass the log to all the specified log drivers filtered by their log driver\n   * configuration. If the driver throws an error while handling a log, an error\n   * log with the caught error message will be created and passed to the stable\n   * log drivers.\n   *\n   * @param log The log with an optional log payload.\n   * @param formattedLog The text representation of the specified log.\n   * @param drivers The log drivers.\n   * @param driverErrors The reported log driver errors.\n   * @param driverErrorIndex Index of the reported driver error to handle.\n   */\n  #logWithErrorHandling(\n    log: LumberjackLog<TPayload>,\n    formattedLog: string,\n    drivers: LumberjackLogDriver<TPayload>[],\n    driverErrors: LumberjackLogDriverError<TPayload>[] = [],\n    driverErrorIndex = noReportedLogDriverErrorIndex\n  ): void {\n    const stableDrivers: LumberjackLogDriver<TPayload>[] = [];\n\n    drivers\n      .filter((driver) => this.#canDriveLog(driver, log.level))\n      .forEach((driver) => {\n        try {\n          this.#driverLogger.log(driver, { formattedLog, log });\n          stableDrivers.push(driver);\n\n          if (driverErrorIndex !== noReportedLogDriverErrorIndex) {\n            this.#removeHandledError(driverErrorIndex, driverErrors);\n            driverErrorIndex = noReportedLogDriverErrorIndex;\n          }\n        } catch (error) {\n          const caughtDriverError: LumberjackLogDriverError<TPayload> = { error, formattedLog, log, logDriver: driver };\n          driverErrors = [...driverErrors, caughtDriverError];\n        }\n      });\n    this.#handleDriverErrors(stableDrivers, driverErrors);\n  }\n\n  /**\n   * Pass the log driver errors to the specified stable log drivers.\n   *\n   * @param driverErrors The reported log driver errors.\n   * @param stableDrivers The log drivers that haven't failed.\n   */\n  #logDriverErrorsToStableDrivers(\n    driverErrors: LumberjackLogDriverError<TPayload>[],\n    stableDrivers: LumberjackLogDriver<TPayload>[]\n  ) {\n    driverErrors.forEach((error, errorIndex) => {\n      const driverErrorLog = this.#createDriverErrorLog(error);\n\n      this.#logWithErrorHandling(driverErrorLog, driverErrorLog.message, stableDrivers, driverErrors, errorIndex);\n    });\n  }\n\n  /**\n   * Output the specified log driver error to the browser console.\n   *\n   * @param driverError The reported log driver error.\n   */\n  #outputDriverError(driverError: LumberjackLogDriverError<TPayload>): void {\n    const errorMessage = formatLogDriverError(driverError);\n\n    console.error(errorMessage);\n  }\n\n  /**\n   * Output the unhandled log driver errors to the browser console.\n   *\n   * @param driverErrors The reported log driver errors.\n   */\n  #outputUnhandledDriverErrors(driverErrors: LumberjackLogDriverError<TPayload>[]) {\n    driverErrors.forEach((error) => this.#outputDriverError(error));\n  }\n\n  /**\n   * Remove the log driver error with the specified index.\n   *\n   * @param driverErrorIndex The index of the log driver error to remove from\n   *   the specified log driver errors.\n   * @param driverErrors The reported log driver errors.\n   */\n  #removeHandledError(driverErrorIndex: number, driverErrors: LumberjackLogDriverError<TPayload>[]) {\n    driverErrors.splice(driverErrorIndex, 1);\n  }\n}\n"]}