channelape-sdk/dist/utils/RequestLogger.js

A client for interacting with ChannelApe's API

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
class RequestLogger {
    constructor(logLevel, endpoint) {
        this.endpoint = endpoint;
        this.logger = undefined;
        try {
            this.channelapeLogger = require('channelape-logger');
        }
        catch (e) {
            this.channelapeLogger = undefined;
        }
        this.getLogger(logLevel);
    }
    logDelay(callCount, delay, requestRetryInfo) {
        const methodAndUrl = `${requestRetryInfo.method} ${this.endpoint}${requestRetryInfo.endpoint}`;
        if (this.logger !== undefined) {
            this.logger.warn(`DELAYING ${methodAndUrl} for ${delay}ms. Delayed ${callCount} times`);
        }
    }
    logCall(method, url, options) {
        let methodToLog = '';
        if (typeof method !== 'undefined') {
            methodToLog = method.toUpperCase();
        }
        let uri;
        let queryParams = '';
        uri = `${this.endpoint}${url}`;
        if (options !== undefined) {
            queryParams = this.getQueryParamString(options.params);
        }
        if (this.logger !== undefined) {
            this.logger.info(`${methodToLog} ${uri}${queryParams} -- STARTED`);
        }
    }
    logResponse(error, response, body, code) {
        let errorMessage;
        let infoMessage = '';
        if (code && response) {
            const errorMessage = `${response.config.method} ${response.config.url} ` +
                `-- FAILED WITH STATUS: ${code}`;
            if (this.logger !== undefined) {
                this.logger.warn(errorMessage);
            }
        }
        else if (response != null && typeof response.config !== 'undefined') {
            if (!this.responseIsLevel200(response.status)) {
                const errorMessage = `${response.config.method} ${response.config.url} ` +
                    `-- FAILED WITH STATUS: ${response.status} and BODY OF: ${JSON.stringify(body)}`;
                if (this.logger !== undefined) {
                    this.logger.warn(errorMessage);
                }
            }
            else {
                infoMessage = `${response.config.method} ${response.config.url} -- COMPLETED`;
            }
        }
        if (infoMessage !== '' && this.logger) {
            this.logger.info(infoMessage);
        }
        if (error != null && this.logger !== undefined) {
            errorMessage = error.message;
            this.logger.error(errorMessage);
        }
    }
    logCallbackError(error) {
        if (this.logger !== undefined) {
            this.logger.error(`Your callback threw the following uncaught error: ${error}`);
        }
    }
    responseIsLevel200(statusCode) {
        return (statusCode >= 200 && statusCode <= 299);
    }
    getQueryParamString(params) {
        if (typeof params === 'undefined') {
            return '';
        }
        if (Object.keys(params).length === 0) {
            return '';
        }
        const queryParams = Object.keys(params).map((k) => {
            return `${k}=${params[k]}`;
        }).join('&');
        return `?${queryParams}`;
    }
    getLogger(logLevel) {
        if (this.channelapeLogger !== undefined) {
            this.logger = new this.channelapeLogger.Logger('ChannelApe API', logLevel);
        }
    }
}
exports.default = RequestLogger;
//# sourceMappingURL=RequestLogger.js.map