ngx-logger
Version:
[](https://www.npmjs.com/package/ngx-logger)
238 lines • 31.8 kB
JavaScript
import { HttpHeaders, HttpParams, HttpRequest, HttpResponse } from '@angular/common/http';
import { Injectable, Optional } from '@angular/core';
import { BehaviorSubject, isObservable, of, throwError, timer } from 'rxjs';
import { catchError, concatMap, filter, map, take } from 'rxjs/operators';
import * as i0 from "@angular/core";
import * as i1 from "@angular/common/http";
export class NGXLoggerServerService {
constructor(httpBackend, ngZone) {
this.httpBackend = httpBackend;
this.ngZone = ngZone;
this.serverCallsQueue = [];
this.flushingQueue = new BehaviorSubject(false);
}
ngOnDestroy() {
if (this.flushingQueue) {
this.flushingQueue.complete();
this.flushingQueue = null;
}
if (this.addToQueueTimer) {
this.addToQueueTimer.unsubscribe();
this.addToQueueTimer = null;
}
}
/**
* Transforms an error object into a readable string (taking only the stack)
* This is needed because JSON.stringify would return "{}"
* @param err the error object
* @returns The stack of the error
*/
secureErrorObject(err) {
return err?.stack;
}
/**
* Transforms the additional parameters to avoid any json error when sending the data to the server
* Basically it just replaces unstringifiable object to a string mentioning an error
* @param additional The additional data to be sent
* @returns The additional data secured
*/
secureAdditionalParameters(additional) {
if (additional === null || additional === undefined) {
return null;
}
return additional.map((next, idx) => {
try {
if (next instanceof Error) {
return this.secureErrorObject(next);
}
// We just want to make sure the JSON can be parsed, we do not want to actually change the type
if (typeof next === 'object') {
JSON.stringify(next);
}
return next;
}
catch (e) {
return `The additional[${idx}] value could not be parsed using JSON.stringify().`;
}
});
}
/**
* Transforms the message so that it can be sent to the server
* @param message the message to be sent
* @returns the message secured
*/
secureMessage(message) {
try {
if (message instanceof Error) {
return this.secureErrorObject(message);
}
if (typeof message !== 'string') {
message = JSON.stringify(message, null, 2);
}
}
catch (e) {
message = 'The provided "message" value could not be parsed with JSON.stringify().';
}
return message;
}
/**
* Edits HttpRequest object before sending request to server
* @param httpRequest default request object
* @returns altered httprequest
*/
alterHttpRequest(httpRequest) {
return httpRequest;
}
/**
* Sends request to server
* @param url
* @param logContent
* @param options
* @returns
*/
logOnServer(url, logContent, options) {
if (!this.httpBackend) {
console.error('NGXLogger : Can\'t log on server because HttpBackend is not provided. You need to import HttpClientModule');
return of(null);
}
// HttpBackend skips all HttpInterceptors
// They may log errors using this service causing circular calls
let defaultRequest = new HttpRequest('POST', url, logContent, options || {});
let finalRequest = of(defaultRequest);
const alteredRequest = this.alterHttpRequest(defaultRequest);
if (isObservable(alteredRequest)) {
finalRequest = alteredRequest;
}
else if (alteredRequest) {
finalRequest = of(alteredRequest);
}
else {
console.warn('NGXLogger : alterHttpRequest returned an invalid request. Using default one instead');
}
return finalRequest.pipe(concatMap(req => {
if (!req) {
console.warn('NGXLogger : alterHttpRequest returned an invalid request (observable). Using default one instead');
return this.httpBackend.handle(defaultRequest);
}
return this.httpBackend.handle(req);
}), filter(e => e instanceof HttpResponse), map((httpResponse) => httpResponse.body));
}
/**
* Customise the data sent to the API
* @param metadata the data provided by NGXLogger
* @returns the data that will be sent to the API in the body
*/
customiseRequestBody(metadata) {
// In our API the body is not customised
return metadata;
}
/**
* Flush the queue of the logger
* @param config
*/
flushQueue(config) {
this.flushingQueue.next(true);
// If a timer was set, we cancel it because the queue is flushed
if (this.addToQueueTimer) {
this.addToQueueTimer.unsubscribe();
this.addToQueueTimer = null;
}
if (!!this.serverCallsQueue && this.serverCallsQueue.length > 0) {
this.sendToServerAction(this.serverCallsQueue, config);
}
this.serverCallsQueue = [];
this.flushingQueue.next(false);
}
sendToServerAction(metadata, config) {
let requestBody;
const secureMetadata = (pMetadata) => {
// Copying metadata locally because we don't want to change the object for the caller
const securedMetadata = { ...pMetadata };
securedMetadata.additional = this.secureAdditionalParameters(securedMetadata.additional);
securedMetadata.message = this.secureMessage(securedMetadata.message);
return securedMetadata;
};
if (Array.isArray(metadata)) {
requestBody = [];
metadata.forEach(m => {
requestBody.push(secureMetadata(m));
});
}
else {
requestBody = secureMetadata(metadata);
}
// Allow users to customise the data sent to the API
requestBody = this.customiseRequestBody(requestBody);
const headers = config.customHttpHeaders || new HttpHeaders();
if (!headers.has('Content-Type')) {
headers.set('Content-Type', 'application/json');
}
const logOnServerAction = () => {
this.logOnServer(config.serverLoggingUrl, requestBody, {
headers,
params: config.customHttpParams || new HttpParams(),
responseType: config.httpResponseType || 'json',
withCredentials: config.withCredentials || false,
}).pipe(catchError(err => {
// Do not use NGXLogger here because this could cause an infinite loop
console.error('NGXLogger: Failed to log on server', err);
return throwError(err);
})).subscribe();
};
if (config.serverCallsOutsideNgZone === true) {
if (!this.ngZone) {
console.error('NGXLogger: NgZone is not provided and serverCallsOutsideNgZone is set to true');
return;
}
this.ngZone.runOutsideAngular(logOnServerAction);
}
else {
logOnServerAction();
}
}
/**
* Sends the content to be logged to the server according to the config
* @param metadata
* @param config
*/
sendToServer(metadata, config) {
// If there is no batch mode in the config, we send the log call straight to the server as usual
if ((!config.serverCallsBatchSize || config.serverCallsBatchSize <= 0) &&
(!config.serverCallsTimer || config.serverCallsTimer <= 0)) {
this.sendToServerAction(metadata, config);
return;
}
const addLogToQueueAction = () => {
this.serverCallsQueue.push({ ...metadata });
// Flush queue when size is reached
if (!!config.serverCallsBatchSize && this.serverCallsQueue.length > config.serverCallsBatchSize) {
this.flushQueue(config);
}
// Call timer only if it is in the config and timer is not already running
if (config.serverCallsTimer > 0 && !this.addToQueueTimer) {
this.addToQueueTimer = timer(config.serverCallsTimer).subscribe(_ => {
this.flushQueue(config);
});
}
};
// If queue is being flushed, we need to wait for it to finish before adding other calls
if (this.flushingQueue.value === true) {
this.flushingQueue.pipe(filter(fq => fq === false), take(1)).subscribe(_ => {
addLogToQueueAction();
});
}
else {
addLogToQueueAction();
}
}
}
/** @nocollapse */ /** @nocollapse */ NGXLoggerServerService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: NGXLoggerServerService, deps: [{ token: i1.HttpBackend, optional: true }, { token: i0.NgZone, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
/** @nocollapse */ /** @nocollapse */ NGXLoggerServerService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: NGXLoggerServerService });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: NGXLoggerServerService, decorators: [{
type: Injectable
}], ctorParameters: function () { return [{ type: i1.HttpBackend, decorators: [{
type: Optional
}] }, { type: i0.NgZone, decorators: [{
type: Optional
}] }]; } });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"server.service.js","sourceRoot":"","sources":["../../../../../src/lib/server/server.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,WAAW,EAAE,UAAU,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACvG,OAAO,EAAE,UAAU,EAAqB,QAAQ,EAAE,MAAM,eAAe,CAAC;AACxE,OAAO,EAAE,eAAe,EAA4B,YAAY,EAAE,EAAE,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,MAAM,CAAC;AACtG,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;;;AAM1E,MAAM,OAAO,sBAAsB;IAKjC,YACiC,WAAwB,EACxB,MAAc;QADd,gBAAW,GAAX,WAAW,CAAa;QACxB,WAAM,GAAN,MAAM,CAAQ;QANrC,qBAAgB,GAAyB,EAAE,CAAC;QAC5C,kBAAa,GAA6B,IAAI,eAAe,CAAC,KAAK,CAAC,CAAC;IAM3E,CAAC;IAEL,WAAW;QACT,IAAI,IAAI,CAAC,aAAa,EAAE;YACtB,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE,CAAC;YAC9B,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;SAC3B;QACD,IAAI,IAAI,CAAC,eAAe,EAAE;YACxB,IAAI,CAAC,eAAe,CAAC,WAAW,EAAE,CAAC;YACnC,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC;SAC7B;IACH,CAAC;IAED;;;;;OAKG;IACO,iBAAiB,CAAC,GAAU;QACpC,OAAO,GAAG,EAAE,KAAK,CAAC;IACpB,CAAC;IAED;;;;;OAKG;IACO,0BAA0B,CAAC,UAAiB;QACpD,IAAI,UAAU,KAAK,IAAI,IAAI,UAAU,KAAK,SAAS,EAAE;YACnD,OAAO,IAAI,CAAC;SACb;QAED,OAAO,UAAU,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE;YAClC,IAAI;gBACF,IAAI,IAAI,YAAY,KAAK,EAAE;oBACzB,OAAO,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;iBACrC;gBACD,+FAA+F;gBAC/F,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE;oBAC5B,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;iBACtB;gBAED,OAAO,IAAI,CAAC;aACb;YAAC,OAAO,CAAC,EAAE;gBACV,OAAO,kBAAkB,GAAG,qDAAqD,CAAC;aACnF;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;;OAIG;IACO,aAAa,CAAC,OAAY;QAClC,IAAI;YACF,IAAI,OAAO,YAAY,KAAK,EAAE;gBAC5B,OAAO,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC;aACxC;YAED,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE;gBAC/B,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;aAC5C;SACF;QAAC,OAAO,CAAC,EAAE;YACV,OAAO,GAAG,yEAAyE,CAAC;SACrF;QAED,OAAO,OAAO,CAAC;IACjB,CAAC;IAED;;;;OAIG;IACO,gBAAgB,CAAC,WAA6B;QACtD,OAAO,WAAW,CAAC;IACrB,CAAC;IAED;;;;;;OAMG;IACO,WAAW,CACnB,GAAW,EACX,UAAe,EACf,OAMC;QAGD,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE;YACrB,OAAO,CAAC,KAAK,CAAC,2GAA2G,CAAC,CAAC;YAC3H,OAAO,EAAE,CAAC,IAAI,CAAC,CAAC;SACjB;QAED,yCAAyC;QACzC,gEAAgE;QAChE,IAAI,cAAc,GAAG,IAAI,WAAW,CAAM,MAAM,EAAE,GAAG,EAAE,UAAU,EAAE,OAAO,IAAI,EAAE,CAAC,CAAC;QAClF,IAAI,YAAY,GAAiC,EAAE,CAAC,cAAc,CAAC,CAAC;QAEpE,MAAM,cAAc,GAAG,IAAI,CAAC,gBAAgB,CAAC,cAAc,CAAC,CAAC;QAE7D,IAAI,YAAY,CAAC,cAAc,CAAC,EAAE;YAChC,YAAY,GAAG,cAAc,CAAC;SAC/B;aAAM,IAAI,cAAc,EAAE;YACzB,YAAY,GAAG,EAAE,CAAC,cAAc,CAAC,CAAC;SACnC;aAAM;YACL,OAAO,CAAC,IAAI,CAAC,qFAAqF,CAAC,CAAC;SACrG;QAED,OAAO,YAAY,CAAC,IAAI,CACtB,SAAS,CAAC,GAAG,CAAC,EAAE;YACd,IAAI,CAAC,GAAG,EAAE;gBACR,OAAO,CAAC,IAAI,CAAC,kGAAkG,CAAC,CAAC;gBACjH,OAAO,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,cAAc,CAAC,CAAA;aAC/C;YACD,OAAO,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QACtC,CAAC,CAAC,EACF,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,YAAY,YAAY,CAAC,EACtC,GAAG,CAAyB,CAAC,YAA+B,EAAE,EAAE,CAAC,YAAY,CAAC,IAAI,CAAC,CACpF,CAAC;IACJ,CAAC;IAED;;;;OAIG;IACO,oBAAoB,CAAC,QAAmD;QAChF,wCAAwC;QACxC,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED;;;OAGG;IACI,UAAU,CAAC,MAAwB;QACxC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAE9B,gEAAgE;QAChE,IAAI,IAAI,CAAC,eAAe,EAAE;YACxB,IAAI,CAAC,eAAe,CAAC,WAAW,EAAE,CAAC;YACnC,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC;SAC7B;QAED,IAAI,CAAC,CAAC,IAAI,CAAC,gBAAgB,IAAI,IAAI,CAAC,gBAAgB,CAAC,MAAM,GAAG,CAAC,EAAE;YAC/D,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,gBAAgB,EAAE,MAAM,CAAC,CAAC;SACxD;QACD,IAAI,CAAC,gBAAgB,GAAG,EAAE,CAAC;QAE3B,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACjC,CAAC;IAES,kBAAkB,CAAC,QAAmD,EAAE,MAAwB;QACxG,IAAI,WAAgB,CAAC;QAErB,MAAM,cAAc,GAAG,CAAC,SAA6B,EAAE,EAAE;YACvD,qFAAqF;YACrF,MAAM,eAAe,GAAuB,EAAE,GAAG,SAAS,EAAE,CAAC;YAC7D,eAAe,CAAC,UAAU,GAAG,IAAI,CAAC,0BAA0B,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC;YACzF,eAAe,CAAC,OAAO,GAAG,IAAI,CAAC,aAAa,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC;YACtE,OAAO,eAAe,CAAC;QACzB,CAAC,CAAA;QAED,IAAI,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE;YAC3B,WAAW,GAAG,EAAE,CAAC;YACjB,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE;gBACnB,WAAW,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC;YACtC,CAAC,CAAC,CAAA;SACH;aAAM;YACL,WAAW,GAAG,cAAc,CAAC,QAAQ,CAAC,CAAC;SACxC;QAED,oDAAoD;QACpD,WAAW,GAAG,IAAI,CAAC,oBAAoB,CAAC,WAAW,CAAC,CAAC;QAErD,MAAM,OAAO,GAAG,MAAM,CAAC,iBAAiB,IAAI,IAAI,WAAW,EAAE,CAAC;QAC9D,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,EAAE;YAChC,OAAO,CAAC,GAAG,CAAC,cAAc,EAAE,kBAAkB,CAAC,CAAC;SACjD;QAED,MAAM,iBAAiB,GAAG,GAAG,EAAE;YAC7B,IAAI,CAAC,WAAW,CACd,MAAM,CAAC,gBAAgB,EACvB,WAAW,EACX;gBACE,OAAO;gBACP,MAAM,EAAE,MAAM,CAAC,gBAAgB,IAAI,IAAI,UAAU,EAAE;gBACnD,YAAY,EAAE,MAAM,CAAC,gBAAgB,IAAI,MAAM;gBAC/C,eAAe,EAAE,MAAM,CAAC,eAAe,IAAI,KAAK;aACjD,CACF,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE;gBACtB,uEAAuE;gBACvE,OAAO,CAAC,KAAK,CAAC,oCAAoC,EAAE,GAAG,CAAC,CAAC;gBACzD,OAAO,UAAU,CAAC,GAAG,CAAC,CAAC;YACzB,CAAC,CAAC,CAAC,CAAC,SAAS,EAAE,CAAC;QAClB,CAAC,CAAC;QAEF,IAAI,MAAM,CAAC,wBAAwB,KAAK,IAAI,EAAE;YAC5C,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE;gBAChB,OAAO,CAAC,KAAK,CAAC,+EAA+E,CAAC,CAAC;gBAC/F,OAAO;aACR;YACD,IAAI,CAAC,MAAM,CAAC,iBAAiB,CAAC,iBAAiB,CAAC,CAAC;SAClD;aAAM;YACL,iBAAiB,EAAE,CAAC;SACrB;IACH,CAAC;IAED;;;;OAIG;IACI,YAAY,CAAC,QAA4B,EAAE,MAAwB;QACxE,gGAAgG;QAChG,IAAI,CAAC,CAAC,MAAM,CAAC,oBAAoB,IAAI,MAAM,CAAC,oBAAoB,IAAI,CAAC,CAAC;YACpE,CAAC,CAAC,MAAM,CAAC,gBAAgB,IAAI,MAAM,CAAC,gBAAgB,IAAI,CAAC,CAAC,EAAE;YAC5D,IAAI,CAAC,kBAAkB,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;YAC1C,OAAO;SACR;QAED,MAAM,mBAAmB,GAAG,GAAG,EAAE;YAC/B,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,EAAE,GAAG,QAAQ,EAAE,CAAC,CAAC;YAE5C,mCAAmC;YACnC,IAAI,CAAC,CAAC,MAAM,CAAC,oBAAoB,IAAI,IAAI,CAAC,gBAAgB,CAAC,MAAM,GAAG,MAAM,CAAC,oBAAoB,EAAE;gBAC/F,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;aACzB;YACD,0EAA0E;YAC1E,IAAI,MAAM,CAAC,gBAAgB,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE;gBACxD,IAAI,CAAC,eAAe,GAAG,KAAK,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE;oBAClE,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;gBAC1B,CAAC,CAAC,CAAC;aACJ;QACH,CAAC,CAAC;QAEF,wFAAwF;QACxF,IAAI,IAAI,CAAC,aAAa,CAAC,KAAK,KAAK,IAAI,EAAE;YACrC,IAAI,CAAC,aAAa,CAAC,IAAI,CACrB,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,KAAK,CAAC,EAC1B,IAAI,CAAC,CAAC,CAAC,CACR,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE;gBACd,mBAAmB,EAAE,CAAC;YACxB,CAAC,CAAC,CAAC;SACJ;aAAM;YACL,mBAAmB,EAAE,CAAC;SACvB;IACH,CAAC;;yJA3QU,sBAAsB;6JAAtB,sBAAsB;2FAAtB,sBAAsB;kBADlC,UAAU;;0BAON,QAAQ;;0BACR,QAAQ","sourcesContent":["import { HttpBackend, HttpHeaders, HttpParams, HttpRequest, HttpResponse } from '@angular/common/http';\r\nimport { Injectable, NgZone, OnDestroy, Optional } from '@angular/core';\r\nimport { BehaviorSubject, Observable, Subscription, isObservable, of, throwError, timer } from 'rxjs';\r\nimport { catchError, concatMap, filter, map, take } from 'rxjs/operators';\r\nimport { INGXLoggerConfig } from '../config/iconfig';\r\nimport { INGXLoggerMetadata } from '../metadata/imetadata';\r\nimport { INGXLoggerServerService } from './iserver.service';\r\n\r\n@Injectable()\r\nexport class NGXLoggerServerService implements INGXLoggerServerService, OnDestroy {\r\n  protected serverCallsQueue: INGXLoggerMetadata[] = [];\r\n  protected flushingQueue: BehaviorSubject<boolean> = new BehaviorSubject(false);\r\n  protected addToQueueTimer: Subscription;\r\n\r\n  constructor(\r\n    @Optional() protected readonly httpBackend: HttpBackend,\r\n    @Optional() protected readonly ngZone: NgZone,\r\n  ) { }\r\n\r\n  ngOnDestroy(): void {\r\n    if (this.flushingQueue) {\r\n      this.flushingQueue.complete();\r\n      this.flushingQueue = null;\r\n    }\r\n    if (this.addToQueueTimer) {\r\n      this.addToQueueTimer.unsubscribe();\r\n      this.addToQueueTimer = null;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Transforms an error object into a readable string (taking only the stack)\r\n   * This is needed because JSON.stringify would return \"{}\"\r\n   * @param err the error object\r\n   * @returns The stack of the error\r\n   */\r\n  protected secureErrorObject(err: Error): string {\r\n    return err?.stack;\r\n  }\r\n\r\n  /**\r\n   * Transforms the additional parameters to avoid any json error when sending the data to the server\r\n   * Basically it just replaces unstringifiable object to a string mentioning an error\r\n   * @param additional The additional data to be sent\r\n   * @returns The additional data secured\r\n   */\r\n  protected secureAdditionalParameters(additional: any[]): any[] {\r\n    if (additional === null || additional === undefined) {\r\n      return null;\r\n    }\r\n\r\n    return additional.map((next, idx) => {\r\n      try {\r\n        if (next instanceof Error) {\r\n          return this.secureErrorObject(next);\r\n        }\r\n        // We just want to make sure the JSON can be parsed, we do not want to actually change the type\r\n        if (typeof next === 'object') {\r\n          JSON.stringify(next);\r\n        }\r\n\r\n        return next;\r\n      } catch (e) {\r\n        return `The additional[${idx}] value could not be parsed using JSON.stringify().`;\r\n      }\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Transforms the message so that it can be sent to the server\r\n   * @param message the message to be sent\r\n   * @returns the message secured\r\n   */\r\n  protected secureMessage(message: any): string {\r\n    try {\r\n      if (message instanceof Error) {\r\n        return this.secureErrorObject(message);\r\n      }\r\n\r\n      if (typeof message !== 'string') {\r\n        message = JSON.stringify(message, null, 2);\r\n      }\r\n    } catch (e) {\r\n      message = 'The provided \"message\" value could not be parsed with JSON.stringify().';\r\n    }\r\n\r\n    return message;\r\n  }\r\n\r\n  /**\r\n   * Edits HttpRequest object before sending request to server\r\n   * @param httpRequest default request object\r\n   * @returns altered httprequest\r\n   */\r\n  protected alterHttpRequest(httpRequest: HttpRequest<any>): HttpRequest<any> | Observable<HttpRequest<any>> {\r\n    return httpRequest;\r\n  }\r\n\r\n  /**\r\n   * Sends request to server\r\n   * @param url \r\n   * @param logContent \r\n   * @param options \r\n   * @returns \r\n   */\r\n  protected logOnServer(\r\n    url: string,\r\n    logContent: any,\r\n    options: {\r\n      headers?: HttpHeaders;\r\n      reportProgress?: boolean;\r\n      params?: HttpParams;\r\n      responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';\r\n      withCredentials?: boolean;\r\n    },\r\n  ): Observable<any> {\r\n\r\n    if (!this.httpBackend) {\r\n      console.error('NGXLogger : Can\\'t log on server because HttpBackend is not provided. You need to import HttpClientModule');\r\n      return of(null);\r\n    }\r\n\r\n    // HttpBackend skips all HttpInterceptors\r\n    // They may log errors using this service causing circular calls\r\n    let defaultRequest = new HttpRequest<any>('POST', url, logContent, options || {});\r\n    let finalRequest: Observable<HttpRequest<any>> = of(defaultRequest);\r\n\r\n    const alteredRequest = this.alterHttpRequest(defaultRequest);\r\n\r\n    if (isObservable(alteredRequest)) {\r\n      finalRequest = alteredRequest;\r\n    } else if (alteredRequest) {\r\n      finalRequest = of(alteredRequest);\r\n    } else {\r\n      console.warn('NGXLogger : alterHttpRequest returned an invalid request. Using default one instead');\r\n    }\r\n\r\n    return finalRequest.pipe(\r\n      concatMap(req => {\r\n        if (!req) {\r\n          console.warn('NGXLogger : alterHttpRequest returned an invalid request (observable). Using default one instead');\r\n          return this.httpBackend.handle(defaultRequest)\r\n        }\r\n        return this.httpBackend.handle(req);\r\n      }),\r\n      filter(e => e instanceof HttpResponse),\r\n      map<HttpResponse<any>, any>((httpResponse: HttpResponse<any>) => httpResponse.body)\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Customise the data sent to the API\r\n   * @param metadata the data provided by NGXLogger\r\n   * @returns the data that will be sent to the API in the body\r\n   */\r\n  protected customiseRequestBody(metadata: INGXLoggerMetadata | INGXLoggerMetadata[]): any {\r\n    // In our API the body is not customised\r\n    return metadata;\r\n  }\r\n\r\n  /**\r\n   * Flush the queue of the logger\r\n   * @param config \r\n   */\r\n  public flushQueue(config: INGXLoggerConfig): void {\r\n    this.flushingQueue.next(true);\r\n\r\n    // If a timer was set, we cancel it because the queue is flushed\r\n    if (this.addToQueueTimer) {\r\n      this.addToQueueTimer.unsubscribe();\r\n      this.addToQueueTimer = null;\r\n    }\r\n\r\n    if (!!this.serverCallsQueue && this.serverCallsQueue.length > 0) {\r\n      this.sendToServerAction(this.serverCallsQueue, config);\r\n    }\r\n    this.serverCallsQueue = [];\r\n\r\n    this.flushingQueue.next(false);\r\n  }\r\n\r\n  protected sendToServerAction(metadata: INGXLoggerMetadata | INGXLoggerMetadata[], config: INGXLoggerConfig): void {\r\n    let requestBody: any;\r\n\r\n    const secureMetadata = (pMetadata: INGXLoggerMetadata) => {\r\n      // Copying metadata locally because we don't want to change the object for the caller\r\n      const securedMetadata: INGXLoggerMetadata = { ...pMetadata };\r\n      securedMetadata.additional = this.secureAdditionalParameters(securedMetadata.additional);\r\n      securedMetadata.message = this.secureMessage(securedMetadata.message);\r\n      return securedMetadata;\r\n    }\r\n\r\n    if (Array.isArray(metadata)) {\r\n      requestBody = [];\r\n      metadata.forEach(m => {\r\n        requestBody.push(secureMetadata(m));\r\n      })\r\n    } else {\r\n      requestBody = secureMetadata(metadata);\r\n    }\r\n\r\n    // Allow users to customise the data sent to the API\r\n    requestBody = this.customiseRequestBody(requestBody);\r\n\r\n    const headers = config.customHttpHeaders || new HttpHeaders();\r\n    if (!headers.has('Content-Type')) {\r\n      headers.set('Content-Type', 'application/json');\r\n    }\r\n\r\n    const logOnServerAction = () => {\r\n      this.logOnServer(\r\n        config.serverLoggingUrl,\r\n        requestBody,\r\n        {\r\n          headers,\r\n          params: config.customHttpParams || new HttpParams(),\r\n          responseType: config.httpResponseType || 'json',\r\n          withCredentials: config.withCredentials || false,\r\n        },\r\n      ).pipe(catchError(err => {\r\n        // Do not use NGXLogger here because this could cause an infinite loop \r\n        console.error('NGXLogger: Failed to log on server', err);\r\n        return throwError(err);\r\n      })).subscribe();\r\n    };\r\n\r\n    if (config.serverCallsOutsideNgZone === true) {\r\n      if (!this.ngZone) {\r\n        console.error('NGXLogger: NgZone is not provided and serverCallsOutsideNgZone is set to true');\r\n        return;\r\n      }\r\n      this.ngZone.runOutsideAngular(logOnServerAction);\r\n    } else {\r\n      logOnServerAction();\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Sends the content to be logged to the server according to the config\r\n   * @param metadata \r\n   * @param config \r\n   */\r\n  public sendToServer(metadata: INGXLoggerMetadata, config: INGXLoggerConfig): void {\r\n    // If there is no batch mode in the config, we send the log call straight to the server as usual\r\n    if ((!config.serverCallsBatchSize || config.serverCallsBatchSize <= 0) &&\r\n      (!config.serverCallsTimer || config.serverCallsTimer <= 0)) {\r\n      this.sendToServerAction(metadata, config);\r\n      return;\r\n    }\r\n\r\n    const addLogToQueueAction = () => {\r\n      this.serverCallsQueue.push({ ...metadata });\r\n\r\n      // Flush queue when size is reached\r\n      if (!!config.serverCallsBatchSize && this.serverCallsQueue.length > config.serverCallsBatchSize) {\r\n        this.flushQueue(config);\r\n      }\r\n      // Call timer only if it is in the config and timer is not already running\r\n      if (config.serverCallsTimer > 0 && !this.addToQueueTimer) {\r\n        this.addToQueueTimer = timer(config.serverCallsTimer).subscribe(_ => {\r\n          this.flushQueue(config);\r\n        });\r\n      }\r\n    };\r\n\r\n    // If queue is being flushed, we need to wait for it to finish before adding other calls\r\n    if (this.flushingQueue.value === true) {\r\n      this.flushingQueue.pipe(\r\n        filter(fq => fq === false),\r\n        take(1),\r\n      ).subscribe(_ => {\r\n        addLogToQueueAction();\r\n      });\r\n    } else {\r\n      addLogToQueueAction();\r\n    }\r\n  }\r\n}\r\n"]}