ngx-logger
Version:
[](https://www.npmjs.com/package/ngx-logger)
114 lines • 16.1 kB
JavaScript
import { HttpHeaders, HttpParams, HttpRequest, HttpResponse } from '@angular/common/http';
import { Injectable, Optional } from '@angular/core';
import { of, throwError } from 'rxjs';
import { catchError, filter, map } from 'rxjs/operators';
import * as i0 from "@angular/core";
import * as i1 from "@angular/common/http";
export class NGXLoggerServerService {
constructor(httpBackend) {
this.httpBackend = httpBackend;
}
/**
* 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 === null || err === void 0 ? void 0 : 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;
}
logOnServer(url, logContent, options) {
// HttpBackend skips all HttpInterceptors
// They may log errors using this service causing circular calls
const req = new HttpRequest('POST', 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);
}
return this.httpBackend.handle(req).pipe(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;
}
sendToServer(metadata, config) {
// Copying metadata locally because we don't want to change the object for the caller
const localMetadata = Object.assign({}, metadata);
localMetadata.additional = this.secureAdditionalParameters(localMetadata.additional);
localMetadata.message = this.secureMessage(localMetadata.message);
// Allow users to customise the data sent to the API
const requestBody = this.customiseRequestBody(localMetadata);
const headers = config.customHttpHeaders || new HttpHeaders();
if (!headers.has('Content-Type')) {
headers.set('Content-Type', 'application/json');
}
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();
}
}
/** @nocollapse */ NGXLoggerServerService.ɵfac = function NGXLoggerServerService_Factory(t) { return new (t || NGXLoggerServerService)(i0.ɵɵinject(i1.HttpBackend, 8)); };
/** @nocollapse */ NGXLoggerServerService.ɵprov = i0.ɵɵdefineInjectable({ token: NGXLoggerServerService, factory: NGXLoggerServerService.ɵfac });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(NGXLoggerServerService, [{
type: Injectable
}], function () { return [{ type: i1.HttpBackend, decorators: [{
type: Optional
}] }]; }, null); })();
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"server.service.js","sourceRoot":"","sources":["../../../../../src/lib/server/server.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpBackend, HttpHeaders, HttpParams, HttpRequest, HttpResponse } from '@angular/common/http';\r\nimport { Injectable, Optional } from '@angular/core';\r\nimport { Observable, of, throwError } from 'rxjs';\r\nimport { catchError, filter, map } from 'rxjs/operators';\r\nimport { INGXLoggerMetadata } from '../metadata/imetadata';\r\nimport { INGXLoggerConfig } from '../config/iconfig';\r\nimport { INGXLoggerServerService } from './iserver.service';\r\n\r\n@Injectable()\r\nexport class NGXLoggerServerService implements INGXLoggerServerService {\r\n\r\n  constructor(\r\n    @Optional() protected readonly httpBackend: HttpBackend,\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  protected logOnServer<T>(\r\n    url: string,\r\n    logContent: T,\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<T> {\r\n    // HttpBackend skips all HttpInterceptors\r\n    // They may log errors using this service causing circular calls\r\n    const req = new HttpRequest<T>('POST', url, logContent, options || {});\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    return this.httpBackend.handle(req).pipe(\r\n      filter(e => e instanceof HttpResponse),\r\n      map<HttpResponse<T>, T>((httpResponse: HttpResponse<T>) => 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): any {\r\n    // In our API the body is not customised\r\n    return metadata;\r\n  }\r\n\r\n  public sendToServer(metadata: INGXLoggerMetadata, config: INGXLoggerConfig): void {\r\n    // Copying metadata locally because we don't want to change the object for the caller\r\n    const localMetadata = { ...metadata };\r\n\r\n    localMetadata.additional = this.secureAdditionalParameters(localMetadata.additional);\r\n\r\n    localMetadata.message = this.secureMessage(localMetadata.message);\r\n\r\n    // Allow users to customise the data sent to the API\r\n    const requestBody = this.customiseRequestBody(localMetadata);\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    this.logOnServer<any>(config.serverLoggingUrl, requestBody, {\r\n      headers,\r\n      params: config.customHttpParams || new HttpParams(),\r\n      responseType: config.httpResponseType || 'json',\r\n      withCredentials: config.withCredentials || false,\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"]}