ngx-logger
Version:
[](https://www.npmjs.com/package/ngx-logger)
154 lines • 22.6 kB
JavaScript
import { Inject, Injectable } from '@angular/core';
import { NgxLoggerLevel } from './types/logger-level.enum';
import { TOKEN_LOGGER_CONFIG } from './config/iconfig';
import { TOKEN_LOGGER_METADATA_SERVICE } from './metadata/imetadata.service';
import { TOKEN_LOGGER_RULES_SERVICE } from './rules/irules.service';
import { TOKEN_LOGGER_MAPPER_SERVICE } from './mapper/imapper.service';
import { TOKEN_LOGGER_WRITER_SERVICE } from './writer/iwriter.service';
import { TOKEN_LOGGER_SERVER_SERVICE } from './server/iserver.service';
import { take } from 'rxjs/operators';
import { TOKEN_LOGGER_CONFIG_ENGINE_FACTORY } from './config/iconfig-engine-factory';
import * as i0 from "@angular/core";
export class NGXLogger {
constructor(config, configEngineFactory, metadataService, ruleService, mapperService, writerService, serverService) {
this.metadataService = metadataService;
this.ruleService = ruleService;
this.mapperService = mapperService;
this.writerService = writerService;
this.serverService = serverService;
this.configEngine = configEngineFactory.provideConfigEngine(config);
}
/** Get a readonly access to the level configured for the NGXLogger */
get level() {
return this.configEngine.level;
}
/** Get a readonly access to the serverLogLevel configured for the NGXLogger */
get serverLogLevel() {
return this.configEngine.serverLogLevel;
}
trace(message, ...additional) {
this._log(NgxLoggerLevel.TRACE, message, additional);
}
debug(message, ...additional) {
this._log(NgxLoggerLevel.DEBUG, message, additional);
}
info(message, ...additional) {
this._log(NgxLoggerLevel.INFO, message, additional);
}
log(message, ...additional) {
this._log(NgxLoggerLevel.LOG, message, additional);
}
warn(message, ...additional) {
this._log(NgxLoggerLevel.WARN, message, additional);
}
error(message, ...additional) {
this._log(NgxLoggerLevel.ERROR, message, additional);
}
fatal(message, ...additional) {
this._log(NgxLoggerLevel.FATAL, message, additional);
}
/** @deprecated customHttpHeaders is now part of the config, this should be updated via @see updateConfig */
setCustomHttpHeaders(headers) {
const config = this.getConfigSnapshot();
config.customHttpHeaders = headers;
this.updateConfig(config);
}
/** @deprecated customHttpParams is now part of the config, this should be updated via @see updateConfig */
setCustomParams(params) {
const config = this.getConfigSnapshot();
config.customHttpParams = params;
this.updateConfig(config);
}
/** @deprecated withCredentials is now part of the config, this should be updated via @see updateConfig */
setWithCredentialsOptionValue(withCredentials) {
const config = this.getConfigSnapshot();
config.withCredentials = withCredentials;
this.updateConfig(config);
}
/**
* Register a INGXLoggerMonitor that will be trigger when a log is either written or sent to server
*
* There is only one monitor, registering one will overwrite the last one if there was one
* @param monitor
*/
registerMonitor(monitor) {
this._loggerMonitor = monitor;
}
/** Set config of logger
*
* Warning : This overwrites all the config, if you want to update only one property, you should use @see getConfigSnapshot before
*/
updateConfig(config) {
this.configEngine.updateConfig(config);
}
partialUpdateConfig(partialConfig) {
this.configEngine.partialUpdateConfig(partialConfig);
}
/** Get config of logger */
getConfigSnapshot() {
return this.configEngine.getConfig();
}
/**
* Flush the serveur queue
*/
flushServerQueue() {
this.serverService.flushQueue(this.getConfigSnapshot());
}
_log(level, message, additional = []) {
const config = this.configEngine.getConfig();
const shouldCallWriter = this.ruleService.shouldCallWriter(level, config, message, additional);
const shouldCallServer = this.ruleService.shouldCallServer(level, config, message, additional);
const shouldCallMonitor = this.ruleService.shouldCallMonitor(level, config, message, additional);
if (!shouldCallWriter && !shouldCallServer && !shouldCallMonitor) {
// If nothing is to be called we return
return;
}
const metadata = this.metadataService.getMetadata(level, config, message, additional);
this.mapperService.getLogPosition(config, metadata).pipe(take(1)).subscribe(logPosition => {
if (logPosition) {
metadata.fileName = logPosition.fileName;
metadata.lineNumber = logPosition.lineNumber;
metadata.columnNumber = logPosition.columnNumber;
}
if (shouldCallMonitor && this._loggerMonitor) {
this._loggerMonitor.onLog(metadata, config);
}
if (shouldCallWriter) {
this.writerService.writeMessage(metadata, config);
}
if (shouldCallServer) {
this.serverService.sendToServer(metadata, config);
}
});
}
}
/** @nocollapse */ /** @nocollapse */ NGXLogger.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: NGXLogger, deps: [{ token: TOKEN_LOGGER_CONFIG }, { token: TOKEN_LOGGER_CONFIG_ENGINE_FACTORY }, { token: TOKEN_LOGGER_METADATA_SERVICE }, { token: TOKEN_LOGGER_RULES_SERVICE }, { token: TOKEN_LOGGER_MAPPER_SERVICE }, { token: TOKEN_LOGGER_WRITER_SERVICE }, { token: TOKEN_LOGGER_SERVER_SERVICE }], target: i0.ɵɵFactoryTarget.Injectable });
/** @nocollapse */ /** @nocollapse */ NGXLogger.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: NGXLogger, providedIn: 'root' });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: NGXLogger, decorators: [{
type: Injectable,
args: [{
providedIn: 'root'
}]
}], ctorParameters: function () { return [{ type: undefined, decorators: [{
type: Inject,
args: [TOKEN_LOGGER_CONFIG]
}] }, { type: undefined, decorators: [{
type: Inject,
args: [TOKEN_LOGGER_CONFIG_ENGINE_FACTORY]
}] }, { type: undefined, decorators: [{
type: Inject,
args: [TOKEN_LOGGER_METADATA_SERVICE]
}] }, { type: undefined, decorators: [{
type: Inject,
args: [TOKEN_LOGGER_RULES_SERVICE]
}] }, { type: undefined, decorators: [{
type: Inject,
args: [TOKEN_LOGGER_MAPPER_SERVICE]
}] }, { type: undefined, decorators: [{
type: Inject,
args: [TOKEN_LOGGER_WRITER_SERVICE]
}] }, { type: undefined, decorators: [{
type: Inject,
args: [TOKEN_LOGGER_SERVER_SERVICE]
}] }]; } });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"logger.service.js","sourceRoot":"","sources":["../../../../src/lib/logger.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core';\r\nimport { HttpHeaders, HttpParams } from '@angular/common/http';\r\nimport { NgxLoggerLevel } from './types/logger-level.enum';\r\nimport { INGXLoggerConfigEngine } from './config/iconfig-engine';\r\nimport { INGXLoggerConfig, TOKEN_LOGGER_CONFIG } from './config/iconfig';\r\nimport { INGXLoggerMetadataService, TOKEN_LOGGER_METADATA_SERVICE } from './metadata/imetadata.service';\r\nimport { INGXLoggerRulesService, TOKEN_LOGGER_RULES_SERVICE } from './rules/irules.service';\r\nimport { INGXLoggerMapperService, TOKEN_LOGGER_MAPPER_SERVICE } from './mapper/imapper.service';\r\nimport { INGXLoggerMonitor } from './monitor/ilogger-monitor';\r\nimport { INGXLoggerWriterService, TOKEN_LOGGER_WRITER_SERVICE } from './writer/iwriter.service';\r\nimport { INGXLoggerServerService, TOKEN_LOGGER_SERVER_SERVICE } from './server/iserver.service';\r\nimport { take } from 'rxjs/operators';\r\nimport { INGXLoggerConfigEngineFactory, TOKEN_LOGGER_CONFIG_ENGINE_FACTORY } from './config/iconfig-engine-factory';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class NGXLogger {\r\n  private _loggerMonitor: INGXLoggerMonitor;\r\n  private configEngine: INGXLoggerConfigEngine;\r\n\r\n  constructor(\r\n    @Inject(TOKEN_LOGGER_CONFIG) config: INGXLoggerConfig,\r\n    @Inject(TOKEN_LOGGER_CONFIG_ENGINE_FACTORY) configEngineFactory: INGXLoggerConfigEngineFactory,\r\n    @Inject(TOKEN_LOGGER_METADATA_SERVICE) private metadataService: INGXLoggerMetadataService,\r\n    @Inject(TOKEN_LOGGER_RULES_SERVICE) private ruleService: INGXLoggerRulesService,\r\n    @Inject(TOKEN_LOGGER_MAPPER_SERVICE) private mapperService: INGXLoggerMapperService,\r\n    @Inject(TOKEN_LOGGER_WRITER_SERVICE) private writerService: INGXLoggerWriterService,\r\n    @Inject(TOKEN_LOGGER_SERVER_SERVICE) private serverService: INGXLoggerServerService,\r\n  ) {\r\n    this.configEngine = configEngineFactory.provideConfigEngine(config);\r\n  }\r\n\r\n  /** Get a readonly access to the level configured for the NGXLogger */\r\n  get level(): NgxLoggerLevel {\r\n    return this.configEngine.level;\r\n  }\r\n\r\n  /** Get a readonly access to the serverLogLevel configured for the NGXLogger */\r\n  get serverLogLevel(): NgxLoggerLevel {\r\n    return this.configEngine.serverLogLevel;\r\n  }\r\n\r\n  public trace(message?: any | (() => any), ...additional: any[]): void {\r\n    this._log(NgxLoggerLevel.TRACE, message, additional);\r\n  }\r\n\r\n  public debug(message?: any | (() => any), ...additional: any[]): void {\r\n    this._log(NgxLoggerLevel.DEBUG, message, additional);\r\n  }\r\n\r\n  public info(message?: any | (() => any), ...additional: any[]): void {\r\n    this._log(NgxLoggerLevel.INFO, message, additional);\r\n  }\r\n\r\n  public log(message?: any | (() => any), ...additional: any[]): void {\r\n    this._log(NgxLoggerLevel.LOG, message, additional);\r\n  }\r\n\r\n  public warn(message?: any | (() => any), ...additional: any[]): void {\r\n    this._log(NgxLoggerLevel.WARN, message, additional);\r\n  }\r\n\r\n  public error(message?: any | (() => any), ...additional: any[]): void {\r\n    this._log(NgxLoggerLevel.ERROR, message, additional);\r\n  }\r\n\r\n  public fatal(message?: any | (() => any), ...additional: any[]): void {\r\n    this._log(NgxLoggerLevel.FATAL, message, additional);\r\n  }\r\n\r\n  /** @deprecated customHttpHeaders is now part of the config, this should be updated via @see updateConfig */\r\n  public setCustomHttpHeaders(headers: HttpHeaders) {\r\n    const config = this.getConfigSnapshot();\r\n    config.customHttpHeaders = headers;\r\n    this.updateConfig(config);\r\n  }\r\n\r\n  /** @deprecated customHttpParams is now part of the config, this should be updated via @see updateConfig */\r\n  public setCustomParams(params: HttpParams) {\r\n    const config = this.getConfigSnapshot();\r\n    config.customHttpParams = params;\r\n    this.updateConfig(config);\r\n  }\r\n\r\n  /** @deprecated withCredentials is now part of the config, this should be updated via @see updateConfig */\r\n  public setWithCredentialsOptionValue(withCredentials: boolean) {\r\n    const config = this.getConfigSnapshot();\r\n    config.withCredentials = withCredentials;\r\n    this.updateConfig(config);\r\n  }\r\n\r\n  /**\r\n   * Register a INGXLoggerMonitor that will be trigger when a log is either written or sent to server\r\n   * \r\n   * There is only one monitor, registering one will overwrite the last one if there was one\r\n   * @param monitor \r\n   */\r\n  public registerMonitor(monitor: INGXLoggerMonitor) {\r\n    this._loggerMonitor = monitor;\r\n  }\r\n\r\n  /** Set config of logger\r\n   * \r\n   * Warning : This overwrites all the config, if you want to update only one property, you should use @see getConfigSnapshot before\r\n   */\r\n  public updateConfig(config: INGXLoggerConfig) {\r\n    this.configEngine.updateConfig(config);\r\n  }\r\n\r\n  public partialUpdateConfig(partialConfig: Partial<INGXLoggerConfig>): void {\r\n    this.configEngine.partialUpdateConfig(partialConfig);\r\n  }\r\n\r\n  /** Get config of logger */\r\n  public getConfigSnapshot(): INGXLoggerConfig {\r\n    return this.configEngine.getConfig();\r\n  }\r\n\r\n  /**\r\n   * Flush the serveur queue\r\n   */\r\n  public flushServerQueue(): void {\r\n    this.serverService.flushQueue(this.getConfigSnapshot());\r\n  }\r\n\r\n  private _log(level: NgxLoggerLevel, message?: any | (() => any), additional: any[] = []): void {\r\n    const config = this.configEngine.getConfig();\r\n\r\n    const shouldCallWriter = this.ruleService.shouldCallWriter(level, config, message, additional);\r\n    const shouldCallServer = this.ruleService.shouldCallServer(level, config, message, additional);\r\n    const shouldCallMonitor = this.ruleService.shouldCallMonitor(level, config, message, additional);\r\n\r\n    if (!shouldCallWriter && !shouldCallServer && !shouldCallMonitor) {\r\n      // If nothing is to be called we return\r\n      return;\r\n    }\r\n\r\n    const metadata = this.metadataService.getMetadata(level, config, message, additional);\r\n    this.mapperService.getLogPosition(config, metadata).pipe(take(1)).subscribe(logPosition => {\r\n      if (logPosition) {\r\n        metadata.fileName = logPosition.fileName;\r\n        metadata.lineNumber = logPosition.lineNumber;\r\n        metadata.columnNumber = logPosition.columnNumber;\r\n      }\r\n\r\n      if (shouldCallMonitor && this._loggerMonitor) {\r\n        this._loggerMonitor.onLog(metadata, config);\r\n      }\r\n      if (shouldCallWriter) {\r\n        this.writerService.writeMessage(metadata, config);\r\n      }\r\n      if (shouldCallServer) {\r\n        this.serverService.sendToServer(metadata, config);\r\n      }\r\n    });\r\n  }\r\n}\r\n"]}