From c7f43f17db6c0c22af87510f034dc529730b38c8 Mon Sep 17 00:00:00 2001 From: Emiliano Sanchez Date: Fri, 19 Mar 2021 15:41:20 -0300 Subject: [PATCH 1/7] moved category to logger options, and optimized methods --- src/logger/__tests__/index.spec.ts | 4 +- src/logger/__tests__/sdkLogger.spec.ts | 2 +- src/logger/browser/debugLogger.ts | 2 +- src/logger/browser/errorLogger.ts | 2 +- src/logger/browser/infoLogger.ts | 2 +- src/logger/browser/warnLogger.ts | 2 +- src/logger/index.ts | 55 ++++++++++--------- src/logger/types.ts | 1 + .../logger/builtinLogger.ts | 2 +- .../logger/pluggableLogger.ts | 8 +-- 10 files changed, 42 insertions(+), 38 deletions(-) diff --git a/src/logger/__tests__/index.spec.ts b/src/logger/__tests__/index.spec.ts index b56491d2..3a08510d 100644 --- a/src/logger/__tests__/index.spec.ts +++ b/src/logger/__tests__/index.spec.ts @@ -27,7 +27,7 @@ test('SPLIT LOGGER / LogLevels exposed mappings', () => { test('SPLIT LOGGER / Logger class shape', () => { expect(typeof Logger).toBe('function'); // Logger should be a class we can instantiate. - const logger = new Logger('test-category'); + const logger = new Logger({ prefix: 'test-category' }); expect(typeof logger.debug).toBe('function'); // instance.debug should be a method. expect(typeof logger.info).toBe('function'); // instance.info should be a method. @@ -57,7 +57,7 @@ function testLogLevels(levelToTest: LogLevel) { let testForNoLog = false; const logMethod = levelToTest.toLowerCase(); const logCategory = `test-category-${logMethod}`; - const instance = new Logger(logCategory, { showLevel }); + const instance = new Logger({ prefix: logCategory, showLevel }); LOG_LEVELS_IN_ORDER.forEach((logLevel, i) => { const logMsg = `Test log for level ${levelToTest} with showLevel: ${showLevel} ${logLevelLogsCounter}`; diff --git a/src/logger/__tests__/sdkLogger.spec.ts b/src/logger/__tests__/sdkLogger.spec.ts index 6776e679..6fc87787 100644 --- a/src/logger/__tests__/sdkLogger.spec.ts +++ b/src/logger/__tests__/sdkLogger.spec.ts @@ -3,7 +3,7 @@ import { Logger, LogLevels } from '../index'; test('LoggerAPI / methods and props', () => { // creates a LoggerAPI instance - const logger = new Logger('category'); + const logger = new Logger(); const API = createLoggerAPI(logger); expect(typeof API).toBe('object'); // Our logger should expose an API object. diff --git a/src/logger/browser/debugLogger.ts b/src/logger/browser/debugLogger.ts index 119b2f05..d1a2aee8 100644 --- a/src/logger/browser/debugLogger.ts +++ b/src/logger/browser/debugLogger.ts @@ -6,6 +6,6 @@ import { codesDebug } from '../messages/debug'; import { _Map } from '../../utils/lang/maps'; export const debugLogger = new Logger( - 'splitio', { logLevel: 'DEBUG' }, + { logLevel: 'DEBUG' }, new _Map(codesError.concat(codesWarn, codesInfo, codesDebug)) ); diff --git a/src/logger/browser/errorLogger.ts b/src/logger/browser/errorLogger.ts index 7423d7fc..33aaa4a5 100644 --- a/src/logger/browser/errorLogger.ts +++ b/src/logger/browser/errorLogger.ts @@ -3,6 +3,6 @@ import { codesError } from '../messages/error'; import { _Map } from '../../utils/lang/maps'; export const errorLogger = new Logger( - 'splitio', { logLevel: 'ERROR' }, + { logLevel: 'ERROR' }, new _Map(codesError) ); diff --git a/src/logger/browser/infoLogger.ts b/src/logger/browser/infoLogger.ts index c88c7c8d..70eada90 100644 --- a/src/logger/browser/infoLogger.ts +++ b/src/logger/browser/infoLogger.ts @@ -5,6 +5,6 @@ import { codesInfo } from '../messages/info'; import { _Map } from '../../utils/lang/maps'; export const infoLogger = new Logger( - 'splitio', { logLevel: 'INFO' }, + { logLevel: 'INFO' }, new _Map(codesError.concat(codesWarn, codesInfo)) ); diff --git a/src/logger/browser/warnLogger.ts b/src/logger/browser/warnLogger.ts index 348d4284..5af9440c 100644 --- a/src/logger/browser/warnLogger.ts +++ b/src/logger/browser/warnLogger.ts @@ -4,6 +4,6 @@ import { codesWarn } from '../messages/warn'; import { _Map } from '../../utils/lang/maps'; export const warnLogger = new Logger( - 'splitio', { logLevel: 'WARN' }, + { logLevel: 'WARN' }, new _Map(codesError.concat(codesWarn)) ); diff --git a/src/logger/index.ts b/src/logger/index.ts index 27b43ab0..afb3b8ac 100644 --- a/src/logger/index.ts +++ b/src/logger/index.ts @@ -12,6 +12,14 @@ export const LogLevels: { [level: string]: LogLevel } = { NONE: 'NONE' }; +const logLevelRanks = { + DEBUG: 1, + INFO: 2, + WARN: 3, + ERROR: 4, + NONE: 5 +}; + export function isLogLevelString(str: string): str is LogLevel { return !!find(LogLevels, (lvl: string) => str === lvl); } @@ -24,53 +32,53 @@ function sprintf(format: string = '', args: any[] = []): string { } const defaultOptions = { + prefix: 'splitio', logLevel: LogLevels.NONE, showLevel: true, }; export class Logger implements ILogger { - private category: string; private options: Required; private codes: IMap; + private logLevel: number; - constructor(category: string, options?: ILoggerOptions, codes?: IMap) { - this.category = category; + constructor(options?: ILoggerOptions, codes?: IMap) { this.options = objectAssign({}, defaultOptions, options); this.codes = codes || new _Map(); + this.logLevel = logLevelRanks[this.options.logLevel]; } setLogLevel(logLevel: LogLevel) { this.options.logLevel = logLevel; + this.logLevel = logLevelRanks[logLevel]; } debug(msg: string | number, args?: any[]) { - this._log(LogLevels.DEBUG, msg, args); + if (this._shouldLog(logLevelRanks.DEBUG)) this._log(LogLevels.DEBUG, msg, args); } info(msg: string | number, args?: any[]) { - this._log(LogLevels.INFO, msg, args); + if (this._shouldLog(logLevelRanks.INFO)) this._log(LogLevels.INFO, msg, args); } warn(msg: string | number, args?: any[]) { - this._log(LogLevels.WARN, msg, args); + if (this._shouldLog(logLevelRanks.WARN)) this._log(LogLevels.WARN, msg, args); } error(msg: string | number, args?: any[]) { - this._log(LogLevels.ERROR, msg, args); + if (this._shouldLog(logLevelRanks.ERROR)) this._log(LogLevels.ERROR, msg, args); } - private _log(level: LogLevel, msg: string | number, args?: any[]) { - if (this._shouldLog(level)) { - if (typeof msg === 'number') { - const format = this.codes.get(msg); - if (format) msg = sprintf(format, args); - else msg = `Message code ${msg}${args ? ', with args: ' + args.toString() : ''}`; - } - const formattedText = this._generateLogMessage(level, msg); - - console.log(formattedText); + _log(level: LogLevel, msg: string | number, args?: any[]) { + if (typeof msg === 'number') { + const format = this.codes.get(msg); + if (format) msg = sprintf(format, args); + else msg = `Message code ${msg}${args ? ', with args: ' + args.toString() : ''}`; } + const formattedText = this._generateLogMessage(level, msg); + + console.log(formattedText); } private _generateLogMessage(level: LogLevel, text: string) { @@ -81,19 +89,14 @@ export class Logger implements ILogger { result += '[' + level + ']' + (level === LogLevels.INFO || level === LogLevels.WARN ? ' ' : '') + ' '; } - if (this.category) { - result += this.category + textPre; + if (this.options.prefix) { + result += this.options.prefix + textPre; } return result += text; } - private _shouldLog(level: LogLevel) { - const logLevel = this.options.logLevel; - const levels = Object.keys(LogLevels).map((f) => LogLevels[f as keyof typeof LogLevels]); - const index = levels.indexOf(level); // What's the index of what it's trying to check if it should log - const levelIdx = levels.indexOf(logLevel); // What's the current log level index. - - return index >= levelIdx; + private _shouldLog(level: number) { + return level >= this.logLevel; } } diff --git a/src/logger/types.ts b/src/logger/types.ts index d691d255..4cacdba8 100644 --- a/src/logger/types.ts +++ b/src/logger/types.ts @@ -1,6 +1,7 @@ import { LogLevel } from '../types'; export interface ILoggerOptions { + prefix?: string, logLevel?: LogLevel, showLevel?: boolean, } diff --git a/src/utils/settingsValidation/logger/builtinLogger.ts b/src/utils/settingsValidation/logger/builtinLogger.ts index 2ef50b97..d1d65b27 100644 --- a/src/utils/settingsValidation/logger/builtinLogger.ts +++ b/src/utils/settingsValidation/logger/builtinLogger.ts @@ -63,7 +63,7 @@ export function validateLogger(settings: { debug: unknown }): ILogger { const settingLogLevel = settings.debug ? getLogLevel(settings.debug) : initialLogLevel; - const log = new Logger('splitio', { logLevel: settingLogLevel || initialLogLevel }, allCodes); + const log = new Logger({ logLevel: settingLogLevel || initialLogLevel }, allCodes); // logs error if the provided settings debug value is invalid if (!settingLogLevel) log.error('Invalid Log Level - No changes to the logs will be applied.'); diff --git a/src/utils/settingsValidation/logger/pluggableLogger.ts b/src/utils/settingsValidation/logger/pluggableLogger.ts index 2a644618..e5fa4f90 100644 --- a/src/utils/settingsValidation/logger/pluggableLogger.ts +++ b/src/utils/settingsValidation/logger/pluggableLogger.ts @@ -1,4 +1,4 @@ -import { Logger } from '../../../logger'; +import { Logger, LogLevels } from '../../../logger'; import { ILogger } from '../../../logger/types'; function isLogger(log: any): log is ILogger { @@ -13,15 +13,15 @@ function isLogger(log: any): log is ILogger { */ export function validateLogger(settings: { debug: unknown }): ILogger { const { debug } = settings; - const log = new Logger('splitio', { logLevel: 'NONE' }); + const log = new Logger(); // @TODO support boolean and string values? if (!debug) return log; if (isLogger(debug)) return debug; - // logs error, for consistency with builtin logger validator - log.error('The provided `debug` value at config is invalid.'); + // logs error for consistency with builtin logger validator + log._log(LogLevels.ERROR, 'The provided `debug` value at config is invalid.'); return log; } From 8758d56f7c4ec6c9a0d6a8e426959492596a7ee0 Mon Sep 17 00:00:00 2001 From: Emiliano Sanchez Date: Fri, 19 Mar 2021 17:10:56 -0300 Subject: [PATCH 2/7] logger validator UTs --- .../logger/__tests__/index.spec.ts | 61 +++++++++++++++++++ .../logger/builtinLogger.ts | 30 +++------ .../settingsValidation/logger/commons.ts | 24 ++++++++ .../logger/pluggableLogger.ts | 26 +++++--- 4 files changed, 110 insertions(+), 31 deletions(-) create mode 100644 src/utils/settingsValidation/logger/__tests__/index.spec.ts create mode 100644 src/utils/settingsValidation/logger/commons.ts diff --git a/src/utils/settingsValidation/logger/__tests__/index.spec.ts b/src/utils/settingsValidation/logger/__tests__/index.spec.ts new file mode 100644 index 00000000..158b5c10 --- /dev/null +++ b/src/utils/settingsValidation/logger/__tests__/index.spec.ts @@ -0,0 +1,61 @@ +import { ILogger } from '../../../../logger/types'; +import { LogLevel } from '../../../../types'; +import { loggerMock } from '../../../../logger/__tests__/sdkLogger.mock'; + +import { validateLogger as pluggableValidateLogger } from '../pluggableLogger'; +import { validateLogger as builtinValidateLogger } from '../builtinLogger'; + +const testTargets = [ + [pluggableValidateLogger], + [builtinValidateLogger] +]; + +function getLogLevel(logger?: ILogger): LogLevel | undefined { // @ts-ignore + if (logger) return logger.options.logLevel; +} + +describe('logger validators', () => { + + const consoleLogSpy = jest.spyOn(global.console, 'log'); + afterEach(() => { consoleLogSpy.mockClear(); }); + + test.each(testTargets)('returns a NONE logger if `debug` property is not defined or false', (validateLogger) => { // @ts-ignore + expect(getLogLevel(validateLogger({}))).toBe('NONE'); + expect(getLogLevel(validateLogger({ debug: undefined }))).toBe('NONE'); + expect(getLogLevel(validateLogger({ debug: false }))).toBe('NONE'); + + expect(consoleLogSpy).not.toBeCalled(); + }); + + test.each(testTargets)('returns a NONE logger if `debug` property is invalid and logs the error', (validateLogger) => { + expect(getLogLevel(validateLogger({ debug: null }))).toBe('NONE'); + expect(getLogLevel(validateLogger({ debug: 10 }))).toBe('NONE'); + expect(getLogLevel(validateLogger({ debug: {} }))).toBe('NONE'); + + expect(consoleLogSpy).toBeCalledTimes(3); + }); + + test.each(testTargets)('returns a logger with the provided log level if `debug` property is true or a string log level', (validateLogger) => { + expect(getLogLevel(validateLogger({ debug: true }))).toBe('DEBUG'); + expect(getLogLevel(validateLogger({ debug: 'DEBUG' }))).toBe('DEBUG'); + expect(getLogLevel(validateLogger({ debug: 'INFO' }))).toBe('INFO'); + expect(getLogLevel(validateLogger({ debug: 'WARN' }))).toBe('WARN'); + expect(getLogLevel(validateLogger({ debug: 'ERROR' }))).toBe('ERROR'); + expect(getLogLevel(validateLogger({ debug: 'NONE' }))).toBe('NONE'); + + expect(consoleLogSpy).not.toBeCalled(); + }); + + test('pluggable logger validators / returns the provided logger at `debug` property if it is valid', () => { + expect(pluggableValidateLogger({ debug: loggerMock })).toBe(loggerMock); + + expect(consoleLogSpy).not.toBeCalled(); + }); + + test('builtin logger validators / returns a NONE logger if `debug` property is invalid and logs the error', () => { + expect(getLogLevel(builtinValidateLogger({ debug: loggerMock }))).toBe('NONE'); + + expect(consoleLogSpy).toBeCalledTimes(1); + }); + +}); diff --git a/src/utils/settingsValidation/logger/builtinLogger.ts b/src/utils/settingsValidation/logger/builtinLogger.ts index d1d65b27..86eaa824 100644 --- a/src/utils/settingsValidation/logger/builtinLogger.ts +++ b/src/utils/settingsValidation/logger/builtinLogger.ts @@ -1,6 +1,5 @@ import { isLogLevelString, Logger, LogLevels } from '../../../logger'; import { ILogger } from '../../../logger/types'; -import { LogLevel } from '../../../types'; import { isLocalStorageAvailable } from '../../env/isLocalStorageAvailable'; import { isNode } from '../../env/isNode'; import { codesError } from '../../../logger/messages/error'; @@ -8,6 +7,8 @@ import { codesWarn } from '../../../logger/messages/warn'; import { codesInfo } from '../../../logger/messages/info'; import { codesDebug } from '../../../logger/messages/debug'; import { _Map } from '../../lang/maps'; +import { getLogLevel } from './commons'; +import { LogLevel } from '../../../types'; const allCodes = new _Map(codesError.concat(codesWarn, codesInfo, codesDebug)); @@ -37,36 +38,21 @@ if (/^(enabled?|on)/i.test(initialState)) { initialLogLevel = initialState; } -// returns the LogLevel for the given debugValue or undefined if it is invalid. -// debugValue must be a boolean or LogLevel string. -export function getLogLevel(debugValue: unknown): LogLevel | undefined { - if (typeof debugValue === 'boolean') { - if (debugValue) { - return LogLevels.DEBUG; - } else { - return LogLevels.NONE; - } - } else if (typeof debugValue === 'string' && isLogLevelString(debugValue)) { - return debugValue; - } else { - return undefined; - } -} - /** * Validates the `debug` property at config and use it to set the log level. * - * @param settings user config object + * @param settings user config object, with an optional `debug` property of type boolean or string log level. * @returns a logger instance with the log level at `settings.debug`. If `settings.debug` is invalid or not provided, `initialLogLevel` is used. */ export function validateLogger(settings: { debug: unknown }): ILogger { + const { debug } = settings; - const settingLogLevel = settings.debug ? getLogLevel(settings.debug) : initialLogLevel; + const logLevel: LogLevel | undefined = debug !== undefined ? getLogLevel(debug) : initialLogLevel; - const log = new Logger({ logLevel: settingLogLevel || initialLogLevel }, allCodes); + const log = new Logger({ logLevel: logLevel || initialLogLevel }, allCodes); - // logs error if the provided settings debug value is invalid - if (!settingLogLevel) log.error('Invalid Log Level - No changes to the logs will be applied.'); + // if logLevel is undefined at this point, it means that settings `debug` value is invalid + if (!logLevel) log._log(LogLevels.ERROR, 'Invalid Log Level - No changes to the logs will be applied.'); return log; } diff --git a/src/utils/settingsValidation/logger/commons.ts b/src/utils/settingsValidation/logger/commons.ts new file mode 100644 index 00000000..ed7e2f54 --- /dev/null +++ b/src/utils/settingsValidation/logger/commons.ts @@ -0,0 +1,24 @@ + +import { LogLevels, isLogLevelString } from '../../../logger'; +import { LogLevel } from '../../../types'; + +/** + * Returns the LogLevel for the given debugValue or undefined if it is invalid, + * i.e., if the debugValue is not a boolean or LogLevel string. + * + * @param debugValue debug value at config + * @returns LogLevel of the given debugValue + */ +export function getLogLevel(debugValue: unknown): LogLevel | undefined { + if (typeof debugValue === 'boolean') { + if (debugValue) { + return LogLevels.DEBUG; + } else { + return LogLevels.NONE; + } + } else if (typeof debugValue === 'string' && isLogLevelString(debugValue)) { + return debugValue; + } else { + return undefined; + } +} diff --git a/src/utils/settingsValidation/logger/pluggableLogger.ts b/src/utils/settingsValidation/logger/pluggableLogger.ts index e5fa4f90..d93a6cc4 100644 --- a/src/utils/settingsValidation/logger/pluggableLogger.ts +++ b/src/utils/settingsValidation/logger/pluggableLogger.ts @@ -1,27 +1,35 @@ import { Logger, LogLevels } from '../../../logger'; import { ILogger } from '../../../logger/types'; +import { LogLevel } from '../../../types'; +import { getLogLevel } from './commons'; function isLogger(log: any): log is ILogger { return log && typeof log.debug === 'function' && typeof log.info === 'function' && typeof log.warn === 'function' && typeof log.error === 'function' && typeof log.setLogLevel === 'function'; } +// By default it starts disabled. +let initialLogLevel = LogLevels.NONE; + /** - * Validates the `debug` (logger) property at config. + * Validates the `debug` property at config and use it to set the logger. * - * @param settings user config object - * @returns the provided logger at `settings.debug` or a new one with NONE log level if the provided one is invalid + * @param settings user config object, with an optional `debug` property of type boolean, string log level or a Logger object. + * @returns a logger instance, that might be: the provided logger at `settings.debug`, or one with the given `debug` log level, + * or one with NONE log level if `debug` is not defined or invalid. */ export function validateLogger(settings: { debug: unknown }): ILogger { const { debug } = settings; - const log = new Logger(); + let logLevel: LogLevel | undefined = initialLogLevel; - // @TODO support boolean and string values? - if (!debug) return log; + if (debug !== undefined) { + if (isLogger(debug)) return debug; + logLevel = getLogLevel(settings.debug); + } - if (isLogger(debug)) return debug; + const log = new Logger({ logLevel: logLevel || initialLogLevel }); - // logs error for consistency with builtin logger validator - log._log(LogLevels.ERROR, 'The provided `debug` value at config is invalid.'); + // if logLevel is undefined at this point, it means that `debug` value is invalid + if (!logLevel) log._log(LogLevels.ERROR, 'Invalid `debug` value at config. Logs will be disabled.'); return log; } From 7c52907bb1dc0fa8357ae81c45b8a168ef17a17e Mon Sep 17 00:00:00 2001 From: Emiliano Sanchez Date: Fri, 19 Mar 2021 18:04:13 -0300 Subject: [PATCH 3/7] added UTs --- src/logger/__tests__/index.spec.ts | 27 ++++++++++++--- src/logger/__tests__/sdkLogger.mock.ts | 5 +++ src/logger/__tests__/sdkLogger.spec.ts | 17 +++++----- src/logger/index.ts | 5 +-- .../logger/__tests__/index.spec.ts | 34 ++++++++----------- 5 files changed, 54 insertions(+), 34 deletions(-) diff --git a/src/logger/__tests__/index.spec.ts b/src/logger/__tests__/index.spec.ts index 3a08510d..82f5c16b 100644 --- a/src/logger/__tests__/index.spec.ts +++ b/src/logger/__tests__/index.spec.ts @@ -1,5 +1,6 @@ import { LogLevel } from '../../types'; -import { Logger, LogLevels, isLogLevelString } from '../index'; +import { _Map } from '../../utils/lang/maps'; +import { Logger, LogLevels, isLogLevelString, _sprintf } from '../index'; // We'll set this only once. These are the constants we will use for // comparing the LogLevel values. @@ -52,12 +53,13 @@ function testLogLevels(levelToTest: LogLevel) { const consoleLogSpy = jest.spyOn(global.console, 'log'); // Runs the suite with the given value for showLevel option. - const runTests = (showLevel?: boolean) => { + const runTests = (showLevel?: boolean, useCodes?: boolean) => { let logLevelLogsCounter = 0; let testForNoLog = false; const logMethod = levelToTest.toLowerCase(); const logCategory = `test-category-${logMethod}`; - const instance = new Logger({ prefix: logCategory, showLevel }); + const instance = new Logger({ prefix: logCategory, showLevel }, + useCodes ? new _Map([[1, 'Test log for level %s with showLevel: %s %s']]) : undefined); LOG_LEVELS_IN_ORDER.forEach((logLevel, i) => { const logMsg = `Test log for level ${levelToTest} with showLevel: ${showLevel} ${logLevelLogsCounter}`; @@ -67,7 +69,8 @@ function testLogLevels(levelToTest: LogLevel) { instance.setLogLevel(LogLevels[logLevel]); // Call the method // @ts-ignore - instance[logMethod](logMsg); + if (useCodes) instance[logMethod](1, [levelToTest, showLevel, logLevelLogsCounter]); // @ts-ignore + else instance[logMethod](logMsg); // Assert if console.log was called. const actualMessage = consoleLogSpy.mock.calls[consoleLogSpy.mock.calls.length - 1][0]; if (testForNoLog) { @@ -87,6 +90,8 @@ function testLogLevels(levelToTest: LogLevel) { runTests(true); // Hide logLevel runTests(false); + // Hide logLevel and use message codes + runTests(false, true); // Restore spied object. consoleLogSpy.mockRestore(); @@ -112,3 +117,17 @@ test('SPLIT LOGGER / Logger class public methods behaviour - instance.error', () testLogLevels(LogLevels.ERROR); }); + +test('_sprintf', () => { + expect(_sprintf()).toBe(''); + expect(_sprintf(undefined, [/regex/, 'arg', 10, {}])).toBe(''); + + expect(_sprintf('text')).toBe('text'); + expect(_sprintf('text', [])).toBe('text'); + expect(_sprintf('text', [/regex/, 'arg', 10, {}])).toBe('text'); + + expect(_sprintf('text %s', [])).toBe('text undefined'); + expect(_sprintf('text %s', ['arg1'])).toBe('text arg1'); + expect(_sprintf('text %s', ['arg1', 'arg2'])).toBe('text arg1'); + expect(_sprintf('%s text %s', ['arg1', true, 'arg3'])).toBe('arg1 text true'); +}); diff --git a/src/logger/__tests__/sdkLogger.mock.ts b/src/logger/__tests__/sdkLogger.mock.ts index f7af2c62..a2cc184f 100644 --- a/src/logger/__tests__/sdkLogger.mock.ts +++ b/src/logger/__tests__/sdkLogger.mock.ts @@ -1,3 +1,4 @@ +import { LogLevel } from '../../types'; export const loggerMock = { warn: jest.fn(), @@ -14,3 +15,7 @@ export const loggerMock = { this.setLogLevel.mockClear(); } }; + +export function getLoggerLogLevel(logger: any): LogLevel | undefined { + if (logger) return logger.options.logLevel; +} diff --git a/src/logger/__tests__/sdkLogger.spec.ts b/src/logger/__tests__/sdkLogger.spec.ts index 6fc87787..a69a587c 100644 --- a/src/logger/__tests__/sdkLogger.spec.ts +++ b/src/logger/__tests__/sdkLogger.spec.ts @@ -1,5 +1,6 @@ import { createLoggerAPI } from '../sdkLogger'; import { Logger, LogLevels } from '../index'; +import { getLoggerLogLevel } from './sdkLogger.mock'; test('LoggerAPI / methods and props', () => { // creates a LoggerAPI instance @@ -9,19 +10,19 @@ test('LoggerAPI / methods and props', () => { expect(typeof API).toBe('object'); // Our logger should expose an API object. expect(typeof API.setLogLevel).toBe('function'); // API object should have setLogLevel method. - API.setLogLevel('INFO'); // @ts-ignore, accessing private prop - expect(logger.options.logLevel).toBe('INFO'); // calling setLogLevel should update the log level. + API.setLogLevel('INFO'); + expect(getLoggerLogLevel(logger)).toBe('INFO'); // calling setLogLevel should update the log level. // @ts-ignore, passing wrong type - API.setLogLevel('warn'); // @ts-ignore, accessing private prop - expect(logger.options.logLevel).toBe('INFO'); // calling setLogLevel with an invalid value should not update the log level. + API.setLogLevel('warn'); + expect(getLoggerLogLevel(logger)).toBe('INFO'); // calling setLogLevel with an invalid value should not update the log level. expect(typeof API.enable).toBe('function'); // API object should have enable method. - API.enable(); // @ts-ignore, accessing private prop - expect(logger.options.logLevel).toBe('DEBUG'); // calling enable should update logger log level to DEBUG. + API.enable(); + expect(getLoggerLogLevel(logger)).toBe('DEBUG'); // calling enable should update logger log level to DEBUG. expect(typeof API.disable).toBe('function'); // API object should have disable method. - API.disable(); // @ts-ignore, accessing private prop - expect(logger.options.logLevel).toBe('NONE'); // calling disable should update logger log level to NONE. + API.disable(); + expect(getLoggerLogLevel(logger)).toBe('NONE'); // calling disable should update logger log level to NONE. expect(API.LogLevel).toEqual(LogLevels); // API object should have LogLevel prop including all available levels. diff --git a/src/logger/index.ts b/src/logger/index.ts index afb3b8ac..6989c808 100644 --- a/src/logger/index.ts +++ b/src/logger/index.ts @@ -24,7 +24,8 @@ export function isLogLevelString(str: string): str is LogLevel { return !!find(LogLevels, (lvl: string) => str === lvl); } -function sprintf(format: string = '', args: any[] = []): string { +// exported for testing purposes only +export function _sprintf(format: string = '', args: any[] = []): string { var i = 0; return format.replace(/%s/g, function () { return args[i++]; @@ -73,7 +74,7 @@ export class Logger implements ILogger { _log(level: LogLevel, msg: string | number, args?: any[]) { if (typeof msg === 'number') { const format = this.codes.get(msg); - if (format) msg = sprintf(format, args); + if (format) msg = _sprintf(format, args); else msg = `Message code ${msg}${args ? ', with args: ' + args.toString() : ''}`; } const formattedText = this._generateLogMessage(level, msg); diff --git a/src/utils/settingsValidation/logger/__tests__/index.spec.ts b/src/utils/settingsValidation/logger/__tests__/index.spec.ts index 158b5c10..2aee9882 100644 --- a/src/utils/settingsValidation/logger/__tests__/index.spec.ts +++ b/src/utils/settingsValidation/logger/__tests__/index.spec.ts @@ -1,6 +1,4 @@ -import { ILogger } from '../../../../logger/types'; -import { LogLevel } from '../../../../types'; -import { loggerMock } from '../../../../logger/__tests__/sdkLogger.mock'; +import { loggerMock, getLoggerLogLevel } from '../../../../logger/__tests__/sdkLogger.mock'; import { validateLogger as pluggableValidateLogger } from '../pluggableLogger'; import { validateLogger as builtinValidateLogger } from '../builtinLogger'; @@ -10,38 +8,34 @@ const testTargets = [ [builtinValidateLogger] ]; -function getLogLevel(logger?: ILogger): LogLevel | undefined { // @ts-ignore - if (logger) return logger.options.logLevel; -} - describe('logger validators', () => { const consoleLogSpy = jest.spyOn(global.console, 'log'); afterEach(() => { consoleLogSpy.mockClear(); }); test.each(testTargets)('returns a NONE logger if `debug` property is not defined or false', (validateLogger) => { // @ts-ignore - expect(getLogLevel(validateLogger({}))).toBe('NONE'); - expect(getLogLevel(validateLogger({ debug: undefined }))).toBe('NONE'); - expect(getLogLevel(validateLogger({ debug: false }))).toBe('NONE'); + expect(getLoggerLogLevel(validateLogger({}))).toBe('NONE'); + expect(getLoggerLogLevel(validateLogger({ debug: undefined }))).toBe('NONE'); + expect(getLoggerLogLevel(validateLogger({ debug: false }))).toBe('NONE'); expect(consoleLogSpy).not.toBeCalled(); }); test.each(testTargets)('returns a NONE logger if `debug` property is invalid and logs the error', (validateLogger) => { - expect(getLogLevel(validateLogger({ debug: null }))).toBe('NONE'); - expect(getLogLevel(validateLogger({ debug: 10 }))).toBe('NONE'); - expect(getLogLevel(validateLogger({ debug: {} }))).toBe('NONE'); + expect(getLoggerLogLevel(validateLogger({ debug: null }))).toBe('NONE'); + expect(getLoggerLogLevel(validateLogger({ debug: 10 }))).toBe('NONE'); + expect(getLoggerLogLevel(validateLogger({ debug: {} }))).toBe('NONE'); expect(consoleLogSpy).toBeCalledTimes(3); }); test.each(testTargets)('returns a logger with the provided log level if `debug` property is true or a string log level', (validateLogger) => { - expect(getLogLevel(validateLogger({ debug: true }))).toBe('DEBUG'); - expect(getLogLevel(validateLogger({ debug: 'DEBUG' }))).toBe('DEBUG'); - expect(getLogLevel(validateLogger({ debug: 'INFO' }))).toBe('INFO'); - expect(getLogLevel(validateLogger({ debug: 'WARN' }))).toBe('WARN'); - expect(getLogLevel(validateLogger({ debug: 'ERROR' }))).toBe('ERROR'); - expect(getLogLevel(validateLogger({ debug: 'NONE' }))).toBe('NONE'); + expect(getLoggerLogLevel(validateLogger({ debug: true }))).toBe('DEBUG'); + expect(getLoggerLogLevel(validateLogger({ debug: 'DEBUG' }))).toBe('DEBUG'); + expect(getLoggerLogLevel(validateLogger({ debug: 'INFO' }))).toBe('INFO'); + expect(getLoggerLogLevel(validateLogger({ debug: 'WARN' }))).toBe('WARN'); + expect(getLoggerLogLevel(validateLogger({ debug: 'ERROR' }))).toBe('ERROR'); + expect(getLoggerLogLevel(validateLogger({ debug: 'NONE' }))).toBe('NONE'); expect(consoleLogSpy).not.toBeCalled(); }); @@ -53,7 +47,7 @@ describe('logger validators', () => { }); test('builtin logger validators / returns a NONE logger if `debug` property is invalid and logs the error', () => { - expect(getLogLevel(builtinValidateLogger({ debug: loggerMock }))).toBe('NONE'); + expect(getLoggerLogLevel(builtinValidateLogger({ debug: loggerMock }))).toBe('NONE'); expect(consoleLogSpy).toBeCalledTimes(1); }); From ba357d6455ca5d99a0ab530f11c9172d7662338c Mon Sep 17 00:00:00 2001 From: Emiliano Sanchez Date: Fri, 19 Mar 2021 19:26:30 -0300 Subject: [PATCH 4/7] refactor Logger functions --- .../{debugLogger.ts => DebugLogger.ts} | 7 +++---- .../{errorLogger.ts => ErrorLogger.ts} | 7 +++---- .../browser/{infoLogger.ts => InfoLogger.ts} | 7 +++---- .../browser/{warnLogger.ts => WarnLogger.ts} | 7 +++---- src/logger/browser/__tests__/index.spec.ts | 21 +++++++++++++++++++ 5 files changed, 33 insertions(+), 16 deletions(-) rename src/logger/browser/{debugLogger.ts => DebugLogger.ts} (65%) rename src/logger/browser/{errorLogger.ts => ErrorLogger.ts} (56%) rename src/logger/browser/{infoLogger.ts => InfoLogger.ts} (63%) rename src/logger/browser/{warnLogger.ts => WarnLogger.ts} (60%) create mode 100644 src/logger/browser/__tests__/index.spec.ts diff --git a/src/logger/browser/debugLogger.ts b/src/logger/browser/DebugLogger.ts similarity index 65% rename from src/logger/browser/debugLogger.ts rename to src/logger/browser/DebugLogger.ts index d1a2aee8..774c1600 100644 --- a/src/logger/browser/debugLogger.ts +++ b/src/logger/browser/DebugLogger.ts @@ -5,7 +5,6 @@ import { codesInfo } from '../messages/info'; import { codesDebug } from '../messages/debug'; import { _Map } from '../../utils/lang/maps'; -export const debugLogger = new Logger( - { logLevel: 'DEBUG' }, - new _Map(codesError.concat(codesWarn, codesInfo, codesDebug)) -); +export function DebugLogger() { + return new Logger({ logLevel: 'DEBUG' }, new _Map(codesError.concat(codesWarn, codesInfo, codesDebug))); +} diff --git a/src/logger/browser/errorLogger.ts b/src/logger/browser/ErrorLogger.ts similarity index 56% rename from src/logger/browser/errorLogger.ts rename to src/logger/browser/ErrorLogger.ts index 33aaa4a5..f0702d89 100644 --- a/src/logger/browser/errorLogger.ts +++ b/src/logger/browser/ErrorLogger.ts @@ -2,7 +2,6 @@ import { Logger } from '../index'; import { codesError } from '../messages/error'; import { _Map } from '../../utils/lang/maps'; -export const errorLogger = new Logger( - { logLevel: 'ERROR' }, - new _Map(codesError) -); +export function ErrorLogger() { + return new Logger({ logLevel: 'ERROR' }, new _Map(codesError)); +} diff --git a/src/logger/browser/infoLogger.ts b/src/logger/browser/InfoLogger.ts similarity index 63% rename from src/logger/browser/infoLogger.ts rename to src/logger/browser/InfoLogger.ts index 70eada90..e38f41b8 100644 --- a/src/logger/browser/infoLogger.ts +++ b/src/logger/browser/InfoLogger.ts @@ -4,7 +4,6 @@ import { codesWarn } from '../messages/warn'; import { codesInfo } from '../messages/info'; import { _Map } from '../../utils/lang/maps'; -export const infoLogger = new Logger( - { logLevel: 'INFO' }, - new _Map(codesError.concat(codesWarn, codesInfo)) -); +export function InfoLogger() { + return new Logger({ logLevel: 'INFO' }, new _Map(codesError.concat(codesWarn, codesInfo))); +} diff --git a/src/logger/browser/warnLogger.ts b/src/logger/browser/WarnLogger.ts similarity index 60% rename from src/logger/browser/warnLogger.ts rename to src/logger/browser/WarnLogger.ts index 5af9440c..6f6747b0 100644 --- a/src/logger/browser/warnLogger.ts +++ b/src/logger/browser/WarnLogger.ts @@ -3,7 +3,6 @@ import { codesError } from '../messages/error'; import { codesWarn } from '../messages/warn'; import { _Map } from '../../utils/lang/maps'; -export const warnLogger = new Logger( - { logLevel: 'WARN' }, - new _Map(codesError.concat(codesWarn)) -); +export function WarnLogger() { + return new Logger({ logLevel: 'WARN' }, new _Map(codesError.concat(codesWarn))); +} diff --git a/src/logger/browser/__tests__/index.spec.ts b/src/logger/browser/__tests__/index.spec.ts new file mode 100644 index 00000000..178c6a59 --- /dev/null +++ b/src/logger/browser/__tests__/index.spec.ts @@ -0,0 +1,21 @@ +import { getLoggerLogLevel } from '../../__tests__/sdkLogger.mock'; +import { DebugLogger } from '../DebugLogger'; +import { InfoLogger } from '../InfoLogger'; +import { WarnLogger } from '../WarnLogger'; +import { ErrorLogger } from '../ErrorLogger'; + +test('DebugLogger', () => { + expect(getLoggerLogLevel(DebugLogger())).toBe('DEBUG'); +}); + +test('InfoLogger', () => { + expect(getLoggerLogLevel(InfoLogger())).toBe('INFO'); +}); + +test('WarnLogger', () => { + expect(getLoggerLogLevel(WarnLogger())).toBe('WARN'); +}); + +test('ErrorLogger', () => { + expect(getLoggerLogLevel(ErrorLogger())).toBe('ERROR'); +}); From 6598744f1bf3774b2183392b976a2deccde7515e Mon Sep 17 00:00:00 2001 From: Emiliano Sanchez Date: Tue, 23 Mar 2021 11:25:12 -0300 Subject: [PATCH 5/7] feedback --- src/logger/__tests__/index.spec.ts | 2 +- src/logger/index.ts | 24 ++++++++++--------- .../logger/__tests__/index.spec.ts | 14 +++++------ .../logger/builtinLogger.ts | 2 +- .../settingsValidation/logger/commons.ts | 2 +- .../logger/pluggableLogger.ts | 2 +- 6 files changed, 24 insertions(+), 22 deletions(-) diff --git a/src/logger/__tests__/index.spec.ts b/src/logger/__tests__/index.spec.ts index 82f5c16b..93085c25 100644 --- a/src/logger/__tests__/index.spec.ts +++ b/src/logger/__tests__/index.spec.ts @@ -118,7 +118,7 @@ test('SPLIT LOGGER / Logger class public methods behaviour - instance.error', () }); -test('_sprintf', () => { +test('SPLIT LOGGER / _sprintf', () => { expect(_sprintf()).toBe(''); expect(_sprintf(undefined, [/regex/, 'arg', 10, {}])).toBe(''); diff --git a/src/logger/index.ts b/src/logger/index.ts index 6989c808..4738e191 100644 --- a/src/logger/index.ts +++ b/src/logger/index.ts @@ -12,7 +12,7 @@ export const LogLevels: { [level: string]: LogLevel } = { NONE: 'NONE' }; -const logLevelRanks = { +const LogLevelRanks = { DEBUG: 1, INFO: 2, WARN: 3, @@ -26,7 +26,7 @@ export function isLogLevelString(str: string): str is LogLevel { // exported for testing purposes only export function _sprintf(format: string = '', args: any[] = []): string { - var i = 0; + let i = 0; return format.replace(/%s/g, function () { return args[i++]; }); @@ -47,36 +47,38 @@ export class Logger implements ILogger { constructor(options?: ILoggerOptions, codes?: IMap) { this.options = objectAssign({}, defaultOptions, options); this.codes = codes || new _Map(); - this.logLevel = logLevelRanks[this.options.logLevel]; + this.logLevel = LogLevelRanks[this.options.logLevel]; } setLogLevel(logLevel: LogLevel) { this.options.logLevel = logLevel; - this.logLevel = logLevelRanks[logLevel]; + this.logLevel = LogLevelRanks[logLevel]; } debug(msg: string | number, args?: any[]) { - if (this._shouldLog(logLevelRanks.DEBUG)) this._log(LogLevels.DEBUG, msg, args); + if (this._shouldLog(LogLevelRanks.DEBUG)) this._log(LogLevels.DEBUG, msg, args); } info(msg: string | number, args?: any[]) { - if (this._shouldLog(logLevelRanks.INFO)) this._log(LogLevels.INFO, msg, args); + if (this._shouldLog(LogLevelRanks.INFO)) this._log(LogLevels.INFO, msg, args); } warn(msg: string | number, args?: any[]) { - if (this._shouldLog(logLevelRanks.WARN)) this._log(LogLevels.WARN, msg, args); + if (this._shouldLog(LogLevelRanks.WARN)) this._log(LogLevels.WARN, msg, args); } error(msg: string | number, args?: any[]) { - if (this._shouldLog(logLevelRanks.ERROR)) this._log(LogLevels.ERROR, msg, args); + if (this._shouldLog(LogLevelRanks.ERROR)) this._log(LogLevels.ERROR, msg, args); } - _log(level: LogLevel, msg: string | number, args?: any[]) { + private _log(level: LogLevel, msg: string | number, args?: any[]) { if (typeof msg === 'number') { const format = this.codes.get(msg); - if (format) msg = _sprintf(format, args); - else msg = `Message code ${msg}${args ? ', with args: ' + args.toString() : ''}`; + msg = format ? _sprintf(format, args) : `Message code ${msg}${args ? ', with args: ' + args.toString() : ''}`; + } else { + if (args) msg = _sprintf(msg, args); } + const formattedText = this._generateLogMessage(level, msg); console.log(formattedText); diff --git a/src/utils/settingsValidation/logger/__tests__/index.spec.ts b/src/utils/settingsValidation/logger/__tests__/index.spec.ts index 2aee9882..3f91c2db 100644 --- a/src/utils/settingsValidation/logger/__tests__/index.spec.ts +++ b/src/utils/settingsValidation/logger/__tests__/index.spec.ts @@ -26,7 +26,13 @@ describe('logger validators', () => { expect(getLoggerLogLevel(validateLogger({ debug: 10 }))).toBe('NONE'); expect(getLoggerLogLevel(validateLogger({ debug: {} }))).toBe('NONE'); - expect(consoleLogSpy).toBeCalledTimes(3); + if (validateLogger === builtinValidateLogger) { + // for builtinValidateLogger, a logger cannot be passed as `debug` property + expect(getLoggerLogLevel(validateLogger({ debug: loggerMock }))).toBe('NONE'); + expect(consoleLogSpy).toBeCalledTimes(4); + } else { + expect(consoleLogSpy).toBeCalledTimes(3); + } }); test.each(testTargets)('returns a logger with the provided log level if `debug` property is true or a string log level', (validateLogger) => { @@ -46,10 +52,4 @@ describe('logger validators', () => { expect(consoleLogSpy).not.toBeCalled(); }); - test('builtin logger validators / returns a NONE logger if `debug` property is invalid and logs the error', () => { - expect(getLoggerLogLevel(builtinValidateLogger({ debug: loggerMock }))).toBe('NONE'); - - expect(consoleLogSpy).toBeCalledTimes(1); - }); - }); diff --git a/src/utils/settingsValidation/logger/builtinLogger.ts b/src/utils/settingsValidation/logger/builtinLogger.ts index 86eaa824..9c314a7c 100644 --- a/src/utils/settingsValidation/logger/builtinLogger.ts +++ b/src/utils/settingsValidation/logger/builtinLogger.ts @@ -51,7 +51,7 @@ export function validateLogger(settings: { debug: unknown }): ILogger { const log = new Logger({ logLevel: logLevel || initialLogLevel }, allCodes); - // if logLevel is undefined at this point, it means that settings `debug` value is invalid + // @ts-ignore // if logLevel is undefined at this point, it means that settings `debug` value is invalid if (!logLevel) log._log(LogLevels.ERROR, 'Invalid Log Level - No changes to the logs will be applied.'); return log; diff --git a/src/utils/settingsValidation/logger/commons.ts b/src/utils/settingsValidation/logger/commons.ts index ed7e2f54..a51ba991 100644 --- a/src/utils/settingsValidation/logger/commons.ts +++ b/src/utils/settingsValidation/logger/commons.ts @@ -7,7 +7,7 @@ import { LogLevel } from '../../../types'; * i.e., if the debugValue is not a boolean or LogLevel string. * * @param debugValue debug value at config - * @returns LogLevel of the given debugValue + * @returns LogLevel of the given debugValue or undefined if the provided value is invalid */ export function getLogLevel(debugValue: unknown): LogLevel | undefined { if (typeof debugValue === 'boolean') { diff --git a/src/utils/settingsValidation/logger/pluggableLogger.ts b/src/utils/settingsValidation/logger/pluggableLogger.ts index d93a6cc4..90746543 100644 --- a/src/utils/settingsValidation/logger/pluggableLogger.ts +++ b/src/utils/settingsValidation/logger/pluggableLogger.ts @@ -28,7 +28,7 @@ export function validateLogger(settings: { debug: unknown }): ILogger { const log = new Logger({ logLevel: logLevel || initialLogLevel }); - // if logLevel is undefined at this point, it means that `debug` value is invalid + // @ts-ignore // if logLevel is undefined at this point, it means that `debug` value is invalid if (!logLevel) log._log(LogLevels.ERROR, 'Invalid `debug` value at config. Logs will be disabled.'); return log; From c9f2943c7c3919de7e65da349f9a414363f6f74d Mon Sep 17 00:00:00 2001 From: Emiliano Sanchez Date: Tue, 23 Mar 2021 13:01:18 -0300 Subject: [PATCH 6/7] polishing --- .nvmrc | 2 +- src/logger/browser/DebugLogger.ts | 5 +---- src/logger/browser/InfoLogger.ts | 4 +--- src/logger/browser/WarnLogger.ts | 3 +-- src/logger/messages/debug.ts | 5 +++-- src/logger/messages/info.ts | 5 +++-- src/logger/messages/warn.ts | 5 +++-- src/storages/inLocalStorage/MySegmentsCacheInLocal.ts | 4 +--- src/storages/inLocalStorage/SplitsCacheInLocal.ts | 2 +- src/storages/inLocalStorage/constants.ts | 2 ++ src/storages/inLocalStorage/index.ts | 3 +-- src/types.ts | 2 +- src/utils/murmur3/murmur3.ts | 2 +- src/utils/murmur3/murmur3_128.ts | 2 +- src/utils/settingsValidation/logger/builtinLogger.ts | 7 ++----- 15 files changed, 23 insertions(+), 30 deletions(-) create mode 100644 src/storages/inLocalStorage/constants.ts diff --git a/.nvmrc b/.nvmrc index a62187b7..958b5a36 100644 --- a/.nvmrc +++ b/.nvmrc @@ -1 +1 @@ -v10.16 +v14 diff --git a/src/logger/browser/DebugLogger.ts b/src/logger/browser/DebugLogger.ts index 774c1600..105e1890 100644 --- a/src/logger/browser/DebugLogger.ts +++ b/src/logger/browser/DebugLogger.ts @@ -1,10 +1,7 @@ import { Logger } from '../index'; -import { codesError } from '../messages/error'; -import { codesWarn } from '../messages/warn'; -import { codesInfo } from '../messages/info'; import { codesDebug } from '../messages/debug'; import { _Map } from '../../utils/lang/maps'; export function DebugLogger() { - return new Logger({ logLevel: 'DEBUG' }, new _Map(codesError.concat(codesWarn, codesInfo, codesDebug))); + return new Logger({ logLevel: 'DEBUG' }, new _Map(codesDebug)); } diff --git a/src/logger/browser/InfoLogger.ts b/src/logger/browser/InfoLogger.ts index e38f41b8..bdf9be75 100644 --- a/src/logger/browser/InfoLogger.ts +++ b/src/logger/browser/InfoLogger.ts @@ -1,9 +1,7 @@ import { Logger } from '../index'; -import { codesError } from '../messages/error'; -import { codesWarn } from '../messages/warn'; import { codesInfo } from '../messages/info'; import { _Map } from '../../utils/lang/maps'; export function InfoLogger() { - return new Logger({ logLevel: 'INFO' }, new _Map(codesError.concat(codesWarn, codesInfo))); + return new Logger({ logLevel: 'INFO' }, new _Map(codesInfo)); } diff --git a/src/logger/browser/WarnLogger.ts b/src/logger/browser/WarnLogger.ts index 6f6747b0..8456d012 100644 --- a/src/logger/browser/WarnLogger.ts +++ b/src/logger/browser/WarnLogger.ts @@ -1,8 +1,7 @@ import { Logger } from '../index'; -import { codesError } from '../messages/error'; import { codesWarn } from '../messages/warn'; import { _Map } from '../../utils/lang/maps'; export function WarnLogger() { - return new Logger({ logLevel: 'WARN' }, new _Map(codesError.concat(codesWarn))); + return new Logger({ logLevel: 'WARN' }, new _Map(codesWarn)); } diff --git a/src/logger/messages/debug.ts b/src/logger/messages/debug.ts index 714ff483..c39fef55 100644 --- a/src/logger/messages/debug.ts +++ b/src/logger/messages/debug.ts @@ -1,6 +1,7 @@ import { DEBUG_ENGINE_COMBINER_AND, DEBUG_1, DEBUG_2, DEBUG_3, DEBUG_4, DEBUG_5, DEBUG_6, DEBUG_7, DEBUG_8, DEBUG_9, DEBUG_10, DEBUG_11, DEBUG_12, DEBUG_13, DEBUG_14, DEBUG_15, DEBUG_16, DEBUG_17, DEBUG_18, DEBUG_19, DEBUG_20, DEBUG_21, DEBUG_22, DEBUG_23, DEBUG_24, DEBUG_25, DEBUG_32, DEBUG_33, DEBUG_36, DEBUG_42, DEBUG_43, DEBUG_44, DEBUG_45, DEBUG_46, DEBUG_47, DEBUG_48, DEBUG_49, DEBUG_50, DEBUG_SPLITS_FILTER, SETTINGS_LB, ENGINE_LB, ENGINE_COMBINER_LB, ENGINE_MATCHER_LB, ENGINE_VALUE_LB, SYNC_OFFLINE_LB, IMPRESSIONS_TRACKER_LB, SYNC_LB, SYNC_SPLITS_LB, SYNC_STREAMING_LB, CLEANUP_LB, DEBUG_26, DEBUG_27 } from '../constants'; +import { codesInfo } from './info'; -export const codesDebug: [number, string][] = [ +export const codesDebug: [number, string][] = codesInfo.concat([ // evaluator [DEBUG_ENGINE_COMBINER_AND, ENGINE_COMBINER_LB + '[andCombiner] evaluates to %s'], [DEBUG_1, ENGINE_COMBINER_LB + 'Treatment found: %s'], @@ -46,4 +47,4 @@ export const codesDebug: [number, string][] = [ [DEBUG_50, IMPRESSIONS_TRACKER_LB + 'Successfully stored %s impression%s.'], // initialization / settings validation [DEBUG_SPLITS_FILTER, SETTINGS_LB + ': splits filtering criteria is "%s".'] -]; +]); diff --git a/src/logger/messages/info.ts b/src/logger/messages/info.ts index 665ca8d8..16f542c6 100644 --- a/src/logger/messages/info.ts +++ b/src/logger/messages/info.ts @@ -1,8 +1,9 @@ import { INFO_CLIENT_READY_FROM_CACHE, INFO_CLIENT_READY, INFO_2, INFO_3, INFO_4, INFO_5, INFO_6, INFO_7, INFO_8, INFO_9, INFO_10, INFO_11, INFO_12, INFO_13, INFO_14, INFO_15, INFO_16, INFO_17, INFO_18, INFO_19, INFO_20, INFO_21, EVENTS_TRACKER_LB, SYNC_MANAGER_LB, SYNC_POLLING_LB, SYNC_SPLITS_LB, SYNC_STREAMING_LB, SYNC_SUBMITTERS_LB, IMPRESSIONS_TRACKER_LB } from '../constants'; +import { codesWarn } from './warn'; const READY_MSG = 'Split SDK is ready'; -export const codesInfo: [number, string][] = [ +export const codesInfo: [number, string][] = codesWarn.concat([ // client status [INFO_CLIENT_READY_FROM_CACHE, READY_MSG + ' from cache'], [INFO_CLIENT_READY, READY_MSG], @@ -28,4 +29,4 @@ export const codesInfo: [number, string][] = [ [INFO_18, SYNC_MANAGER_LB + 'Streaming not available. Starting polling.'], [INFO_19, SYNC_MANAGER_LB + 'Streaming couldn\'t connect. Continue polling.'], [INFO_20, SYNC_MANAGER_LB + 'Streaming (re)connected. Syncing and stopping polling.'], -]; +]); diff --git a/src/logger/messages/warn.ts b/src/logger/messages/warn.ts index f351cd2d..c3338be4 100644 --- a/src/logger/messages/warn.ts +++ b/src/logger/messages/warn.ts @@ -1,6 +1,7 @@ import { WARN_ENGINE_INVALID_VALUE, WARN_ENGINE_NO_ATTRIBUTES, WARN_CLIENT_NO_LISTENER, WARN_4, WARN_5, WARN_6, WARN_7, WARN_8, WARN_9, WARN_10, WARN_11, WARN_SETTING_NULL, WARN_TRIMMING_PROPERTIES, WARN_CLIENT_NOT_READY, WARN_CONVERTING, WARN_TRIMMING, WARN_NOT_EXISTENT_SPLIT, WARN_LOWERCASE_TRAFFIC_TYPE, WARN_NOT_EXISTENT_TT, WARN_INTEGRATION_INVALID, WARN_SPLITS_FILTER_IGNORED, WARN_SPLITS_FILTER_INVALID, WARN_SPLITS_FILTER_EMPTY, WARN_STORAGE_INVALID, WARN_API_KEY, SETTINGS_LB, ENGINE_VALUE_LB, EVENTS_TRACKER_LB, SYNC_MYSEGMENTS_LB, SYNC_SPLITS_LB, SYNC_STREAMING_LB, SYNC_SUBMITTERS_LB } from '../constants'; +import { codesError } from './error'; -export const codesWarn: [number, string][] = [ +export const codesWarn: [number, string][] = codesError.concat([ // evaluator [WARN_ENGINE_INVALID_VALUE, ENGINE_VALUE_LB + 'Value %s doesn\'t match with expected type.'], [WARN_ENGINE_NO_ATTRIBUTES, ENGINE_VALUE_LB + 'Defined attribute [%s], no attributes received.'], @@ -32,4 +33,4 @@ export const codesWarn: [number, string][] = [ [WARN_SPLITS_FILTER_EMPTY, SETTINGS_LB+': splitFilters configuration must be a non-empty array of filter objects.'], [WARN_STORAGE_INVALID, SETTINGS_LB+': The provided storage is invalid. Fallbacking into default MEMORY storage'], [WARN_API_KEY, SETTINGS_LB+': You already have %s. We recommend keeping only one instance of the factory at all times (Singleton pattern) and reusing it throughout your application'] -]; +]); diff --git a/src/storages/inLocalStorage/MySegmentsCacheInLocal.ts b/src/storages/inLocalStorage/MySegmentsCacheInLocal.ts index cfa58b9f..020f823a 100644 --- a/src/storages/inLocalStorage/MySegmentsCacheInLocal.ts +++ b/src/storages/inLocalStorage/MySegmentsCacheInLocal.ts @@ -1,9 +1,7 @@ import { ILogger } from '../../logger/types'; import AbstractSegmentsCacheSync from '../AbstractSegmentsCacheSync'; import KeyBuilderCS from '../KeyBuilderCS'; -import { logPrefix } from './index'; - -const DEFINED = '1'; +import { logPrefix, DEFINED } from './constants'; export default class MySegmentsCacheInLocal extends AbstractSegmentsCacheSync { diff --git a/src/storages/inLocalStorage/SplitsCacheInLocal.ts b/src/storages/inLocalStorage/SplitsCacheInLocal.ts index 47ec5584..58d5ba09 100644 --- a/src/storages/inLocalStorage/SplitsCacheInLocal.ts +++ b/src/storages/inLocalStorage/SplitsCacheInLocal.ts @@ -3,7 +3,7 @@ import AbstractSplitsCacheSync, { usesSegments } from '../AbstractSplitsCacheSyn import { isFiniteNumber, toNumber, isNaNNumber } from '../../utils/lang'; import KeyBuilderCS from '../KeyBuilderCS'; import { ILogger } from '../../logger/types'; -import { logPrefix } from './index'; +import { logPrefix } from './constants'; /** * ISplitsCacheSync implementation that stores split definitions in browser LocalStorage. diff --git a/src/storages/inLocalStorage/constants.ts b/src/storages/inLocalStorage/constants.ts new file mode 100644 index 00000000..74624310 --- /dev/null +++ b/src/storages/inLocalStorage/constants.ts @@ -0,0 +1,2 @@ +export const logPrefix = 'storage:localstorage: '; +export const DEFINED = '1'; diff --git a/src/storages/inLocalStorage/index.ts b/src/storages/inLocalStorage/index.ts index 6a4c8624..226d771c 100644 --- a/src/storages/inLocalStorage/index.ts +++ b/src/storages/inLocalStorage/index.ts @@ -10,8 +10,7 @@ import MySegmentsCacheInMemory from '../inMemory/MySegmentsCacheInMemory'; import SplitsCacheInMemory from '../inMemory/SplitsCacheInMemory'; import { DEFAULT_CACHE_EXPIRATION_IN_MILLIS } from '../../utils/constants/browser'; import { InMemoryStorageCSFactory } from '../inMemory/InMemoryStorageCS'; - -export const logPrefix = 'storage:localstorage: '; +import { logPrefix } from './constants'; export interface InLocalStorageOptions { prefix?: string diff --git a/src/types.ts b/src/types.ts index b60b2bc0..ae2d3fd1 100644 --- a/src/types.ts +++ b/src/types.ts @@ -89,7 +89,7 @@ export interface ISettings { auth: string, streaming: string }, - readonly debug: boolean, + readonly debug: boolean | LogLevel, readonly version: string, features: SplitIO.MockedFeaturesFilePath | SplitIO.MockedFeaturesMap, readonly streamingEnabled: boolean, diff --git a/src/utils/murmur3/murmur3.ts b/src/utils/murmur3/murmur3.ts index 3bdcbc77..434fcbd3 100644 --- a/src/utils/murmur3/murmur3.ts +++ b/src/utils/murmur3/murmur3.ts @@ -1,7 +1,7 @@ /* eslint-disable no-fallthrough */ import { UTF16ToUTF8, x86Fmix, x86Multiply, x86Rotl } from './commons'; -/*! +/* * +----------------------------------------------------------------------------------+ * | murmurHash3.js v3.0.0 (https://github.com/karanlyons/murmurHash3.js) | * | A TypeScript/JavaScript implementation of MurmurHash3's hashing algorithms. | diff --git a/src/utils/murmur3/murmur3_128.ts b/src/utils/murmur3/murmur3_128.ts index 4d5e3cf7..18140e29 100644 --- a/src/utils/murmur3/murmur3_128.ts +++ b/src/utils/murmur3/murmur3_128.ts @@ -6,7 +6,7 @@ const X86 = 'x86'; const X64_ARCHS = ['arm64', 'ppc64', 'x64', 's390x', 'mipsel']; const isX64 = getArchType() === X64; -/*! +/* * +----------------------------------------------------------------------------------+ * | murmurHash3.js v3.0.0 (https://github.com/karanlyons/murmurHash3.js) | * | A TypeScript/JavaScript implementation of MurmurHash3's hashing algorithms. | diff --git a/src/utils/settingsValidation/logger/builtinLogger.ts b/src/utils/settingsValidation/logger/builtinLogger.ts index 9c314a7c..5db9cfb0 100644 --- a/src/utils/settingsValidation/logger/builtinLogger.ts +++ b/src/utils/settingsValidation/logger/builtinLogger.ts @@ -2,17 +2,14 @@ import { isLogLevelString, Logger, LogLevels } from '../../../logger'; import { ILogger } from '../../../logger/types'; import { isLocalStorageAvailable } from '../../env/isLocalStorageAvailable'; import { isNode } from '../../env/isNode'; -import { codesError } from '../../../logger/messages/error'; -import { codesWarn } from '../../../logger/messages/warn'; -import { codesInfo } from '../../../logger/messages/info'; import { codesDebug } from '../../../logger/messages/debug'; import { _Map } from '../../lang/maps'; import { getLogLevel } from './commons'; import { LogLevel } from '../../../types'; -const allCodes = new _Map(codesError.concat(codesWarn, codesInfo, codesDebug)); +const allCodes = new _Map(codesDebug); -// @TODO when integrating with other packages, find the best way to handle initial state per environment +// @TODO set default debug setting instead of initialLogLevel when integrating in JS and Node packages const LS_KEY = 'splitio_debug'; const ENV_VAR_KEY = 'SPLITIO_DEBUG'; From 2d3de2eae9f8413d673f0053dd99d8ee739f2ff6 Mon Sep 17 00:00:00 2001 From: Emiliano Sanchez Date: Thu, 25 Mar 2021 15:55:40 -0300 Subject: [PATCH 7/7] renamed constants --- src/evaluator/combiners/and.ts | 4 +- src/evaluator/combiners/ifelseif.ts | 8 +- src/evaluator/condition/engineUtils.ts | 4 +- src/evaluator/matchers/all.ts | 4 +- src/evaluator/matchers/between.ts | 4 +- src/evaluator/matchers/boolean.ts | 4 +- src/evaluator/matchers/cont_all.ts | 4 +- src/evaluator/matchers/cont_any.ts | 4 +- src/evaluator/matchers/cont_str.ts | 4 +- src/evaluator/matchers/dependency.ts | 6 +- src/evaluator/matchers/eq.ts | 4 +- src/evaluator/matchers/eq_set.ts | 4 +- src/evaluator/matchers/ew.ts | 4 +- src/evaluator/matchers/gte.ts | 4 +- src/evaluator/matchers/lte.ts | 4 +- src/evaluator/matchers/part_of.ts | 4 +- src/evaluator/matchers/segment.ts | 6 +- src/evaluator/matchers/string.ts | 6 +- src/evaluator/matchers/sw.ts | 4 +- src/evaluator/matchers/whitelist.ts | 4 +- src/evaluator/value/index.ts | 8 +- src/evaluator/value/sanitize.ts | 4 +- src/listeners/browser.ts | 6 +- src/listeners/node.ts | 10 +- src/logger/constants.ts | 236 +++++++++--------- src/logger/messages/debug.ts | 84 +++---- src/logger/messages/error.ts | 24 +- src/logger/messages/info.ts | 46 ++-- src/logger/messages/warn.ts | 38 +-- src/logger/sdkLogger.ts | 4 +- .../__tests__/sdkReadinessManager.spec.ts | 14 +- src/readiness/sdkReadinessManager.ts | 8 +- src/sdkClient/client.ts | 6 +- src/sdkClient/sdkClientMethod.ts | 4 +- src/sdkClient/sdkClientMethodCS.ts | 8 +- src/sdkClient/sdkClientMethodCSWithTT.ts | 8 +- src/sdkFactory/index.ts | 8 +- src/services/splitHttpClient.ts | 6 +- .../offline/syncTasks/fromObjectSyncTask.ts | 6 +- src/sync/polling/pollingManagerCS.ts | 8 +- src/sync/polling/pollingManagerSS.ts | 10 +- .../polling/syncTasks/mySegmentsSyncTask.ts | 4 +- .../polling/syncTasks/segmentsSyncTask.ts | 10 +- src/sync/polling/syncTasks/splitsSyncTask.ts | 14 +- src/sync/streaming/SSEHandler/index.ts | 10 +- src/sync/streaming/pushManager.ts | 16 +- src/sync/streaming/pushManagerCS.ts | 16 +- src/sync/streaming/pushManagerSS.ts | 16 +- src/sync/submitters/eventsSyncTask.ts | 4 +- src/sync/submitters/submitterSyncTask.ts | 10 +- src/sync/syncManagerOnline.ts | 8 +- src/sync/syncTask.ts | 8 +- src/trackers/eventTracker.ts | 6 +- src/trackers/impressionsTracker.ts | 8 +- .../__tests__/isOperational.spec.ts | 4 +- src/utils/inputValidation/apiKey.ts | 8 +- src/utils/inputValidation/isOperational.ts | 4 +- .../__tests__/splitFilters.spec.ts | 8 +- .../logger/pluggableLogger.ts | 2 +- src/utils/settingsValidation/splitFilters.ts | 6 +- 60 files changed, 399 insertions(+), 399 deletions(-) diff --git a/src/evaluator/combiners/and.ts b/src/evaluator/combiners/and.ts index 7f0dbc95..271801dd 100644 --- a/src/evaluator/combiners/and.ts +++ b/src/evaluator/combiners/and.ts @@ -3,7 +3,7 @@ import { ILogger } from '../../logger/types'; import thenable from '../../utils/promise/thenable'; import { MaybeThenable } from '../../dtos/types'; import { IMatcher } from '../types'; -import { DEBUG_ENGINE_COMBINER_AND } from '../../logger/constants'; +import { ENGINE_COMBINER_AND } from '../../logger/constants'; export default function andCombinerContext(log: ILogger, matchers: IMatcher[]) { @@ -11,7 +11,7 @@ export default function andCombinerContext(log: ILogger, matchers: IMatcher[]) { // Array.prototype.every is supported by target environments const hasMatchedAll = results.every(value => value); - log.debug(DEBUG_ENGINE_COMBINER_AND, [hasMatchedAll]); + log.debug(ENGINE_COMBINER_AND, [hasMatchedAll]); return hasMatchedAll; } diff --git a/src/evaluator/combiners/ifelseif.ts b/src/evaluator/combiners/ifelseif.ts index cf3bf834..9aa162f7 100644 --- a/src/evaluator/combiners/ifelseif.ts +++ b/src/evaluator/combiners/ifelseif.ts @@ -5,12 +5,12 @@ import * as LabelsConstants from '../../utils/labels'; import { CONTROL } from '../../utils/constants'; import { SplitIO } from '../../types'; import { IEvaluation, IEvaluator, ISplitEvaluator } from '../types'; -import { DEBUG_1, DEBUG_2, ERROR_0 } from '../../logger/constants'; +import { ENGINE_COMBINER_IFELSEIF, ENGINE_COMBINER_IFELSEIF_NO_TREATMENT, ERROR_ENGINE_COMBINER_IFELSEIF } from '../../logger/constants'; export default function ifElseIfCombinerContext(log: ILogger, predicates: IEvaluator[]): IEvaluator { function unexpectedInputHandler() { - log.error(ERROR_0); + log.error(ERROR_ENGINE_COMBINER_IFELSEIF); return { treatment: CONTROL, @@ -25,13 +25,13 @@ export default function ifElseIfCombinerContext(log: ILogger, predicates: IEvalu const evaluation = predicateResults[i]; if (evaluation !== undefined) { - log.debug(DEBUG_1, [evaluation.treatment]); + log.debug(ENGINE_COMBINER_IFELSEIF, [evaluation.treatment]); return evaluation; } } - log.debug(DEBUG_2); + log.debug(ENGINE_COMBINER_IFELSEIF_NO_TREATMENT); return undefined; } diff --git a/src/evaluator/condition/engineUtils.ts b/src/evaluator/condition/engineUtils.ts index ab4c8fac..bacd3b10 100644 --- a/src/evaluator/condition/engineUtils.ts +++ b/src/evaluator/condition/engineUtils.ts @@ -1,4 +1,4 @@ -import { DEBUG_3 } from '../../logger/constants'; +import { ENGINE_BUCKET } from '../../logger/constants'; import { ILogger } from '../../logger/types'; import { bucket } from '../../utils/murmur3/murmur3'; @@ -10,7 +10,7 @@ export function getTreatment(log: ILogger, key: string, seed: number, treatments const treatment = treatments.getTreatmentFor(_bucket); - log.debug(DEBUG_3, [_bucket, key, seed, treatment]); + log.debug(ENGINE_BUCKET, [_bucket, key, seed, treatment]); return treatment; } diff --git a/src/evaluator/matchers/all.ts b/src/evaluator/matchers/all.ts index 5eb43000..8b8c64fb 100644 --- a/src/evaluator/matchers/all.ts +++ b/src/evaluator/matchers/all.ts @@ -1,9 +1,9 @@ -import { DEBUG_4 } from '../../logger/constants'; +import { ENGINE_MATCHER_ALL } from '../../logger/constants'; import { ILogger } from '../../logger/types'; export default function allMatcherContext(log: ILogger) { return function allMatcher(runtimeAttr: string): boolean { - log.debug(DEBUG_4); + log.debug(ENGINE_MATCHER_ALL); return runtimeAttr != null; }; diff --git a/src/evaluator/matchers/between.ts b/src/evaluator/matchers/between.ts index 46c123dd..f56709b3 100644 --- a/src/evaluator/matchers/between.ts +++ b/src/evaluator/matchers/between.ts @@ -1,5 +1,5 @@ import { IBetweenMatcherData } from '../../dtos/types'; -import { DEBUG_5 } from '../../logger/constants'; +import { ENGINE_MATCHER_BETWEEN } from '../../logger/constants'; import { ILogger } from '../../logger/types'; export default function betweenMatcherContext(log: ILogger, ruleVO: IBetweenMatcherData) /*: Function */ { @@ -7,7 +7,7 @@ export default function betweenMatcherContext(log: ILogger, ruleVO: IBetweenMatc let isBetween = runtimeAttr >= ruleVO.start && runtimeAttr <= ruleVO.end; - log.debug(DEBUG_5, [runtimeAttr, ruleVO.start, ruleVO.end, isBetween]); + log.debug(ENGINE_MATCHER_BETWEEN, [runtimeAttr, ruleVO.start, ruleVO.end, isBetween]); return isBetween; }; diff --git a/src/evaluator/matchers/boolean.ts b/src/evaluator/matchers/boolean.ts index 87281534..6e64a268 100644 --- a/src/evaluator/matchers/boolean.ts +++ b/src/evaluator/matchers/boolean.ts @@ -1,11 +1,11 @@ -import { DEBUG_6 } from '../../logger/constants'; +import { ENGINE_MATCHER_BOOLEAN } from '../../logger/constants'; import { ILogger } from '../../logger/types'; export default function booleanMatcherContext(log: ILogger, ruleAttr: boolean) /*: Function */ { return function booleanMatcher(runtimeAttr: boolean): boolean { let booleanMatches = ruleAttr === runtimeAttr; - log.debug(DEBUG_6, [ruleAttr, runtimeAttr]); + log.debug(ENGINE_MATCHER_BOOLEAN, [ruleAttr, runtimeAttr]); return booleanMatches; }; diff --git a/src/evaluator/matchers/cont_all.ts b/src/evaluator/matchers/cont_all.ts index 3e7f3d4b..02bc35e1 100644 --- a/src/evaluator/matchers/cont_all.ts +++ b/src/evaluator/matchers/cont_all.ts @@ -1,4 +1,4 @@ -import { DEBUG_7 } from '../../logger/constants'; +import { ENGINE_MATCHER_CONTAINS_ALL } from '../../logger/constants'; import { ILogger } from '../../logger/types'; import { findIndex } from '../../utils/lang'; @@ -15,7 +15,7 @@ export default function containsAllMatcherContext(log: ILogger, ruleAttr: string } } - log.debug(DEBUG_7, [runtimeAttr, ruleAttr, containsAll]); + log.debug(ENGINE_MATCHER_CONTAINS_ALL, [runtimeAttr, ruleAttr, containsAll]); return containsAll; }; diff --git a/src/evaluator/matchers/cont_any.ts b/src/evaluator/matchers/cont_any.ts index 68565478..69fcdb3e 100644 --- a/src/evaluator/matchers/cont_any.ts +++ b/src/evaluator/matchers/cont_any.ts @@ -1,4 +1,4 @@ -import { DEBUG_8 } from '../../logger/constants'; +import { ENGINE_MATCHER_CONTAINS_ANY } from '../../logger/constants'; import { ILogger } from '../../logger/types'; import { findIndex } from '../../utils/lang'; @@ -10,7 +10,7 @@ export default function containsAnyMatcherContext(log: ILogger, ruleAttr: string if (findIndex(runtimeAttr, e => e === ruleAttr[i]) >= 0) containsAny = true; } - log.debug(DEBUG_8, [runtimeAttr, ruleAttr, containsAny]); + log.debug(ENGINE_MATCHER_CONTAINS_ANY, [runtimeAttr, ruleAttr, containsAny]); return containsAny; }; diff --git a/src/evaluator/matchers/cont_str.ts b/src/evaluator/matchers/cont_str.ts index 2438d390..0a15d13e 100644 --- a/src/evaluator/matchers/cont_str.ts +++ b/src/evaluator/matchers/cont_str.ts @@ -1,12 +1,12 @@ import { isString } from '../../utils/lang'; import { ILogger } from '../../logger/types'; -import { DEBUG_9 } from '../../logger/constants'; +import { ENGINE_MATCHER_CONTAINS_STRING } from '../../logger/constants'; export default function containsStringMatcherContext(log: ILogger, ruleAttr: string[]) /*: Function */ { return function containsStringMatcher(runtimeAttr: string): boolean { let contains = ruleAttr.some(e => isString(runtimeAttr) && runtimeAttr.indexOf(e) > -1); - log.debug(DEBUG_9, [runtimeAttr, ruleAttr, contains]); + log.debug(ENGINE_MATCHER_CONTAINS_STRING, [runtimeAttr, ruleAttr, contains]); return contains; }; diff --git a/src/evaluator/matchers/dependency.ts b/src/evaluator/matchers/dependency.ts index f5399024..e3b8723b 100644 --- a/src/evaluator/matchers/dependency.ts +++ b/src/evaluator/matchers/dependency.ts @@ -3,7 +3,7 @@ import { IStorageAsync, IStorageSync } from '../../storages/types'; import { ILogger } from '../../logger/types'; import thenable from '../../utils/promise/thenable'; import { IDependencyMatcherValue, IEvaluation, ISplitEvaluator } from '../types'; -import { DEBUG_10, DEBUG_11 } from '../../logger/constants'; +import { ENGINE_MATCHER_DEPENDENCY, ENGINE_MATCHER_DEPENDENCY_PRE } from '../../logger/constants'; export default function dependencyMatcherContext(log: ILogger, { split, treatments }: IDependencyMatcherData, storage: IStorageSync | IStorageAsync) { @@ -14,13 +14,13 @@ export default function dependencyMatcherContext(log: ILogger, { split, treatmen matches = acceptableTreatments.indexOf(evaluation.treatment as string) !== -1; } - log.debug(DEBUG_10, [parentName, evaluation.treatment, evaluation.label, parentName, acceptableTreatments, matches]); + log.debug(ENGINE_MATCHER_DEPENDENCY, [parentName, evaluation.treatment, evaluation.label, parentName, acceptableTreatments, matches]); return matches; } return function dependencyMatcher({ key, attributes }: IDependencyMatcherValue, splitEvaluator: ISplitEvaluator): MaybeThenable { - log.debug(DEBUG_11, [split, JSON.stringify(key), attributes ? '\n attributes: ' + JSON.stringify(attributes) : '']); + log.debug(ENGINE_MATCHER_DEPENDENCY_PRE, [split, JSON.stringify(key), attributes ? '\n attributes: ' + JSON.stringify(attributes) : '']); const evaluation = splitEvaluator(log, key, split, attributes, storage); if (thenable(evaluation)) { diff --git a/src/evaluator/matchers/eq.ts b/src/evaluator/matchers/eq.ts index 724b647d..ddccc264 100644 --- a/src/evaluator/matchers/eq.ts +++ b/src/evaluator/matchers/eq.ts @@ -1,11 +1,11 @@ -import { DEBUG_12 } from '../../logger/constants'; +import { ENGINE_MATCHER_EQUAL } from '../../logger/constants'; import { ILogger } from '../../logger/types'; export default function equalToMatcherContext(log: ILogger, ruleAttr: number) /*: Function */ { return function equalToMatcher(runtimeAttr: number): boolean { let isEqual = runtimeAttr === ruleAttr; - log.debug(DEBUG_12, [runtimeAttr, ruleAttr, isEqual]); + log.debug(ENGINE_MATCHER_EQUAL, [runtimeAttr, ruleAttr, isEqual]); return isEqual; }; diff --git a/src/evaluator/matchers/eq_set.ts b/src/evaluator/matchers/eq_set.ts index 9f920e8a..f0fddd27 100644 --- a/src/evaluator/matchers/eq_set.ts +++ b/src/evaluator/matchers/eq_set.ts @@ -1,4 +1,4 @@ -import { DEBUG_13 } from '../../logger/constants'; +import { ENGINE_MATCHER_EQUAL_TO_SET } from '../../logger/constants'; import { ILogger } from '../../logger/types'; import { findIndex } from '../../utils/lang'; @@ -12,7 +12,7 @@ export default function equalToSetMatcherContext(log: ILogger, ruleAttr: string[ if (findIndex(ruleAttr, e => e === runtimeAttr[i]) < 0) isEqual = false; } - log.debug(DEBUG_13, [runtimeAttr, ruleAttr, isEqual]); + log.debug(ENGINE_MATCHER_EQUAL_TO_SET, [runtimeAttr, ruleAttr, isEqual]); return isEqual; }; diff --git a/src/evaluator/matchers/ew.ts b/src/evaluator/matchers/ew.ts index a956e133..20d46c63 100644 --- a/src/evaluator/matchers/ew.ts +++ b/src/evaluator/matchers/ew.ts @@ -1,4 +1,4 @@ -import { DEBUG_14 } from '../../logger/constants'; +import { ENGINE_MATCHER_ENDS_WITH } from '../../logger/constants'; import { ILogger } from '../../logger/types'; import { endsWith as strEndsWith } from '../../utils/lang'; @@ -6,7 +6,7 @@ export default function endsWithMatcherContext(log: ILogger, ruleAttr: string[]) return function endsWithMatcher(runtimeAttr: string): boolean { let endsWith = ruleAttr.some(e => strEndsWith(runtimeAttr, e)); - log.debug(DEBUG_14, [runtimeAttr, ruleAttr, endsWith]); + log.debug(ENGINE_MATCHER_ENDS_WITH, [runtimeAttr, ruleAttr, endsWith]); return endsWith; }; diff --git a/src/evaluator/matchers/gte.ts b/src/evaluator/matchers/gte.ts index 10e73066..a08f55f5 100644 --- a/src/evaluator/matchers/gte.ts +++ b/src/evaluator/matchers/gte.ts @@ -1,11 +1,11 @@ -import { DEBUG_15 } from '../../logger/constants'; +import { ENGINE_MATCHER_GREATER } from '../../logger/constants'; import { ILogger } from '../../logger/types'; export default function greaterThanEqualMatcherContext(log: ILogger, ruleAttr: number) /*: Function */ { return function greaterThanEqualMatcher(runtimeAttr: number): boolean { let isGreaterEqualThan = runtimeAttr >= ruleAttr; - log.debug(DEBUG_15, [runtimeAttr, ruleAttr, isGreaterEqualThan]); + log.debug(ENGINE_MATCHER_GREATER, [runtimeAttr, ruleAttr, isGreaterEqualThan]); return isGreaterEqualThan; }; diff --git a/src/evaluator/matchers/lte.ts b/src/evaluator/matchers/lte.ts index b594b890..06883b94 100644 --- a/src/evaluator/matchers/lte.ts +++ b/src/evaluator/matchers/lte.ts @@ -1,11 +1,11 @@ -import { DEBUG_16 } from '../../logger/constants'; +import { ENGINE_MATCHER_LESS } from '../../logger/constants'; import { ILogger } from '../../logger/types'; export default function lessThanEqualMatcherContext(log: ILogger, ruleAttr: number) /*: function */ { return function lessThanEqualMatcher(runtimeAttr: number): boolean { let isLessEqualThan = runtimeAttr <= ruleAttr; - log.debug(DEBUG_16, [runtimeAttr, ruleAttr, isLessEqualThan]); + log.debug(ENGINE_MATCHER_LESS, [runtimeAttr, ruleAttr, isLessEqualThan]); return isLessEqualThan; }; diff --git a/src/evaluator/matchers/part_of.ts b/src/evaluator/matchers/part_of.ts index 4b410e99..ccabf3e4 100644 --- a/src/evaluator/matchers/part_of.ts +++ b/src/evaluator/matchers/part_of.ts @@ -1,6 +1,6 @@ import { findIndex } from '../../utils/lang'; import { ILogger } from '../../logger/types'; -import { DEBUG_17 } from '../../logger/constants'; +import { ENGINE_MATCHER_PART_OF } from '../../logger/constants'; export default function partOfMatcherContext(log: ILogger, ruleAttr: string[]) /*: Function */ { return function partOfMatcher(runtimeAttr: string[]): boolean { @@ -12,7 +12,7 @@ export default function partOfMatcherContext(log: ILogger, ruleAttr: string[]) / if (findIndex(ruleAttr, e => e === runtimeAttr[i]) < 0) isPartOf = false; } - log.debug(DEBUG_17, [runtimeAttr, ruleAttr, isPartOf]); + log.debug(ENGINE_MATCHER_PART_OF, [runtimeAttr, ruleAttr, isPartOf]); return isPartOf; }; diff --git a/src/evaluator/matchers/segment.ts b/src/evaluator/matchers/segment.ts index 9f197e0e..7b6f6d4f 100644 --- a/src/evaluator/matchers/segment.ts +++ b/src/evaluator/matchers/segment.ts @@ -2,7 +2,7 @@ import { MaybeThenable } from '../../dtos/types'; import { ISegmentsCacheBase } from '../../storages/types'; import { ILogger } from '../../logger/types'; import thenable from '../../utils/promise/thenable'; -import { DEBUG_18, DEBUG_19 } from '../../logger/constants'; +import { ENGINE_MATCHER_SEGMENT_ASYNC, ENGINE_MATCHER_SEGMENT } from '../../logger/constants'; export default function matcherSegmentContext(log: ILogger, segmentName: string, storage: { segments: ISegmentsCacheBase }) { @@ -11,12 +11,12 @@ export default function matcherSegmentContext(log: ILogger, segmentName: string, if (thenable(isInSegment)) { isInSegment.then(result => { - log.debug(DEBUG_18, [segmentName, key, isInSegment]); + log.debug(ENGINE_MATCHER_SEGMENT_ASYNC, [segmentName, key, isInSegment]); return result; }); } else { - log.debug(DEBUG_19, [segmentName, key, isInSegment]); + log.debug(ENGINE_MATCHER_SEGMENT, [segmentName, key, isInSegment]); } return isInSegment; diff --git a/src/evaluator/matchers/string.ts b/src/evaluator/matchers/string.ts index dff34f8d..f0e0512f 100644 --- a/src/evaluator/matchers/string.ts +++ b/src/evaluator/matchers/string.ts @@ -1,4 +1,4 @@ -import { DEBUG_21, DEBUG_20 } from '../../logger/constants'; +import { ENGINE_MATCHER_STRING_INVALID, ENGINE_MATCHER_STRING } from '../../logger/constants'; import { ILogger } from '../../logger/types'; export default function stringMatcherContext(log: ILogger, ruleAttr: string) /*: Function */ { @@ -8,14 +8,14 @@ export default function stringMatcherContext(log: ILogger, ruleAttr: string) /*: try { re = new RegExp(ruleAttr); } catch (e) { - log.debug(DEBUG_21, [ruleAttr]); + log.debug(ENGINE_MATCHER_STRING_INVALID, [ruleAttr]); return false; } let regexMatches = re.test(runtimeAttr); - log.debug(DEBUG_20, [runtimeAttr, ruleAttr, regexMatches ? 'yes' : 'no']); + log.debug(ENGINE_MATCHER_STRING, [runtimeAttr, ruleAttr, regexMatches ? 'yes' : 'no']); return regexMatches; }; diff --git a/src/evaluator/matchers/sw.ts b/src/evaluator/matchers/sw.ts index f2907c4d..e2bfc03e 100644 --- a/src/evaluator/matchers/sw.ts +++ b/src/evaluator/matchers/sw.ts @@ -1,4 +1,4 @@ -import { DEBUG_22 } from '../../logger/constants'; +import { ENGINE_MATCHER_STARTS_WITH } from '../../logger/constants'; import { ILogger } from '../../logger/types'; import { startsWith } from '../../utils/lang'; @@ -6,7 +6,7 @@ export default function startsWithMatcherContext(log: ILogger, ruleAttr: string[ return function startsWithMatcher(runtimeAttr: string): boolean { let matches = ruleAttr.some(e => startsWith(runtimeAttr, e)); - log.debug(DEBUG_22, [runtimeAttr, ruleAttr, matches]); + log.debug(ENGINE_MATCHER_STARTS_WITH, [runtimeAttr, ruleAttr, matches]); return matches; }; diff --git a/src/evaluator/matchers/whitelist.ts b/src/evaluator/matchers/whitelist.ts index 142be8ad..b84cb129 100644 --- a/src/evaluator/matchers/whitelist.ts +++ b/src/evaluator/matchers/whitelist.ts @@ -1,12 +1,12 @@ import { setToArray, ISet } from '../../utils/lang/sets'; import { ILogger } from '../../logger/types'; -import { DEBUG_23 } from '../../logger/constants'; +import { ENGINE_MATCHER_WHITELIST } from '../../logger/constants'; export default function whitelistMatcherContext(log: ILogger, ruleAttr: ISet) /*: Function */ { return function whitelistMatcher(runtimeAttr: string): boolean { let isInWhitelist = ruleAttr.has(runtimeAttr); - log.debug(DEBUG_23, [runtimeAttr, setToArray(ruleAttr).join(','), isInWhitelist]); + log.debug(ENGINE_MATCHER_WHITELIST, [runtimeAttr, setToArray(ruleAttr).join(','), isInWhitelist]); return isInWhitelist; }; diff --git a/src/evaluator/value/index.ts b/src/evaluator/value/index.ts index 47a928bc..228d7d0a 100644 --- a/src/evaluator/value/index.ts +++ b/src/evaluator/value/index.ts @@ -2,16 +2,16 @@ import { SplitIO } from '../../types'; import { IMatcherDto } from '../types'; import { ILogger } from '../../logger/types'; import sanitizeValue from './sanitize'; -import { DEBUG_24, WARN_ENGINE_NO_ATTRIBUTES, WARN_ENGINE_INVALID_VALUE } from '../../logger/constants'; +import { ENGINE_VALUE, ENGINE_VALUE_NO_ATTRIBUTES, ENGINE_VALUE_INVALID } from '../../logger/constants'; function parseValue(log: ILogger, key: string, attributeName: string | null, attributes: SplitIO.Attributes) { let value = undefined; if (attributeName) { if (attributes) { value = attributes[attributeName]; - log.debug(DEBUG_24, [attributeName, value]); + log.debug(ENGINE_VALUE, [attributeName, value]); } else { - log.warn(WARN_ENGINE_NO_ATTRIBUTES, [attributeName]); + log.warn(ENGINE_VALUE_NO_ATTRIBUTES, [attributeName]); } } else { value = key; @@ -31,7 +31,7 @@ export default function value(log: ILogger, key: string, matcherDto: IMatcherDto if (sanitizedValue !== undefined) { return sanitizedValue; } else { - log.warn(WARN_ENGINE_INVALID_VALUE, [valueToMatch + (attributeName ? ' for attribute ' + attributeName : '')]); + log.warn(ENGINE_VALUE_INVALID, [valueToMatch + (attributeName ? ' for attribute ' + attributeName : '')]); return; } } diff --git a/src/evaluator/value/sanitize.ts b/src/evaluator/value/sanitize.ts index bbc945f1..46cae859 100644 --- a/src/evaluator/value/sanitize.ts +++ b/src/evaluator/value/sanitize.ts @@ -4,7 +4,7 @@ import { ILogger } from '../../logger/types'; import { isObject, uniq, toString, toNumber } from '../../utils/lang'; import { zeroSinceHH, zeroSinceSS } from '../convertions'; import { matcherTypes, dataTypes } from '../matchers/matcherTypes'; -import { DEBUG_25 } from '../../logger/constants'; +import { ENGINE_SANITIZE } from '../../logger/constants'; function sanitizeNumber(val: any): number | undefined { const num = toNumber(val); @@ -99,7 +99,7 @@ export default function sanitize(log: ILogger, matcherTypeID: number, value: str sanitizedValue = processor(sanitizedValue, attributes); } - log.debug(DEBUG_25, [value, dataType, sanitizedValue instanceof Object ? JSON.stringify(sanitizedValue) : sanitizedValue]); + log.debug(ENGINE_SANITIZE, [value, dataType, sanitizedValue instanceof Object ? JSON.stringify(sanitizedValue) : sanitizedValue]); return sanitizedValue; } diff --git a/src/listeners/browser.ts b/src/listeners/browser.ts index a5e14508..d937448e 100644 --- a/src/listeners/browser.ts +++ b/src/listeners/browser.ts @@ -10,7 +10,7 @@ import { ImpressionsPayload } from '../sync/submitters/types'; import { MaybeThenable } from '../dtos/types'; import { OPTIMIZED, DEBUG } from '../utils/constants'; import objectAssign from 'object-assign'; -import { DEBUG_26, DEBUG_27 } from '../logger/constants'; +import { CLEANUP_REGISTERING, CLEANUP_DEREGISTERING } from '../logger/constants'; // 'unload' event is used instead of 'beforeunload', since 'unload' is not a cancelable event, so no other listeners can stop the event from occurring. const UNLOAD_DOM_EVENT = 'unload'; @@ -40,7 +40,7 @@ export default class BrowserSignalListener implements ISignalListener { */ start() { if (typeof window !== 'undefined' && window.addEventListener) { - this.settings.log.debug(DEBUG_26, [EVENT_NAME]); + this.settings.log.debug(CLEANUP_REGISTERING, [EVENT_NAME]); window.addEventListener(UNLOAD_DOM_EVENT, this.flushData); } } @@ -52,7 +52,7 @@ export default class BrowserSignalListener implements ISignalListener { */ stop() { if (typeof window !== 'undefined' && window.removeEventListener) { - this.settings.log.debug(DEBUG_27, [EVENT_NAME]); + this.settings.log.debug(CLEANUP_DEREGISTERING, [EVENT_NAME]); window.removeEventListener(UNLOAD_DOM_EVENT, this.flushData); } } diff --git a/src/listeners/node.ts b/src/listeners/node.ts index 3d799c92..18b01519 100644 --- a/src/listeners/node.ts +++ b/src/listeners/node.ts @@ -3,7 +3,7 @@ import { ISignalListener } from './types'; import thenable from '../utils/promise/thenable'; import { MaybeThenable } from '../dtos/types'; import { ISettings } from '../types'; -import { CLEANUP_LB, DEBUG_26, DEBUG_27 } from '../logger/constants'; +import { logPrefixCleanup, CLEANUP_REGISTERING, CLEANUP_DEREGISTERING } from '../logger/constants'; const SIGTERM = 'SIGTERM'; const EVENT_NAME = 'for SIGTERM signal.'; @@ -25,13 +25,13 @@ export default class NodeSignalListener implements ISignalListener { } start() { - this.settings.log.debug(DEBUG_26, [EVENT_NAME]); + this.settings.log.debug(CLEANUP_REGISTERING, [EVENT_NAME]); // eslint-disable-next-line no-undef process.on(SIGTERM, this._sigtermHandler); } stop() { - this.settings.log.debug(DEBUG_27, [EVENT_NAME]); + this.settings.log.debug(CLEANUP_DEREGISTERING, [EVENT_NAME]); // eslint-disable-next-line no-undef process.removeListener(SIGTERM, this._sigtermHandler); } @@ -49,14 +49,14 @@ export default class NodeSignalListener implements ISignalListener { process.kill(process.pid, SIGTERM); }; - this.settings.log.debug(CLEANUP_LB + 'Split SDK graceful shutdown after SIGTERM.'); + this.settings.log.debug(logPrefixCleanup + 'Split SDK graceful shutdown after SIGTERM.'); let handlerResult = null; try { handlerResult = this.handler(); } catch (err) { - this.settings.log.error(CLEANUP_LB + `Error with Split SDK graceful shutdown: ${err}`); + this.settings.log.error(logPrefixCleanup + `Error with Split SDK graceful shutdown: ${err}`); } if (thenable(handlerResult)) { diff --git a/src/logger/constants.ts b/src/logger/constants.ts index 775577be..8b0c9397 100644 --- a/src/logger/constants.ts +++ b/src/logger/constants.ts @@ -5,109 +5,84 @@ * Modules related to the server-side API (e.g., segmentsSyncTask), platform-specific components (e.g., signal listeners) * and pluggable components (e.g., pluggable integrations & storages) can use the logger with string literals. */ -export const DEBUG_ENGINE_COMBINER_AND = 0; -export const DEBUG_1 = 1; -export const DEBUG_2 = 2; -export const DEBUG_3 = 3; -export const DEBUG_4 = 4; -export const DEBUG_5 = 5; -export const DEBUG_6 = 6; -export const DEBUG_7 = 7; -export const DEBUG_8 = 8; -export const DEBUG_9 = 9; -export const DEBUG_10 = 10; -export const DEBUG_11 = 11; -export const DEBUG_12 = 12; -export const DEBUG_13 = 13; -export const DEBUG_14 = 14; -export const DEBUG_15 = 15; -export const DEBUG_16 = 16; -export const DEBUG_17 = 17; -export const DEBUG_18 = 18; -export const DEBUG_19 = 19; -export const DEBUG_20 = 20; -export const DEBUG_21 = 21; -export const DEBUG_22 = 22; -export const DEBUG_23 = 23; -export const DEBUG_24 = 24; -export const DEBUG_25 = 25; -export const DEBUG_26 = 26; -export const DEBUG_27 = 27; -export const DEBUG_32 = 32; -export const DEBUG_33 = 33; -export const DEBUG_36 = 36; -export const DEBUG_42 = 42; -export const DEBUG_43 = 43; -export const DEBUG_44 = 44; -export const DEBUG_45 = 45; -export const DEBUG_46 = 46; -export const DEBUG_47 = 47; -export const DEBUG_48 = 48; -export const DEBUG_49 = 49; -export const DEBUG_50 = 50; -export const DEBUG_SPLITS_FILTER = 51; +export const ENGINE_COMBINER_AND = 0; +export const ENGINE_COMBINER_IFELSEIF = 1; +export const ENGINE_COMBINER_IFELSEIF_NO_TREATMENT = 2; +export const ENGINE_BUCKET = 3; +export const ENGINE_MATCHER_ALL = 4; +export const ENGINE_MATCHER_BETWEEN = 5; +export const ENGINE_MATCHER_BOOLEAN = 6; +export const ENGINE_MATCHER_CONTAINS_ALL = 7; +export const ENGINE_MATCHER_CONTAINS_ANY = 8; +export const ENGINE_MATCHER_CONTAINS_STRING = 9; +export const ENGINE_MATCHER_DEPENDENCY = 10; +export const ENGINE_MATCHER_DEPENDENCY_PRE = 11; +export const ENGINE_MATCHER_EQUAL = 12; +export const ENGINE_MATCHER_EQUAL_TO_SET = 13; +export const ENGINE_MATCHER_ENDS_WITH = 14; +export const ENGINE_MATCHER_GREATER = 15; +export const ENGINE_MATCHER_LESS = 16; +export const ENGINE_MATCHER_PART_OF = 17; +export const ENGINE_MATCHER_SEGMENT_ASYNC = 18; +export const ENGINE_MATCHER_SEGMENT = 19; +export const ENGINE_MATCHER_STRING = 20; +export const ENGINE_MATCHER_STRING_INVALID = 21; +export const ENGINE_MATCHER_STARTS_WITH = 22; +export const ENGINE_MATCHER_WHITELIST = 23; +export const ENGINE_VALUE = 24; +export const ENGINE_SANITIZE = 25; +export const CLEANUP_REGISTERING = 26; +export const CLEANUP_DEREGISTERING = 27; +export const RETRIEVE_CLIENT_DEFAULT = 32; +export const RETRIEVE_CLIENT_EXISTING = 33; +export const SYNC_OFFLINE_DATA = 36; +export const SYNC_SPLITS_FETCH = 42; +export const SYNC_SPLITS_NEW = 43; +export const SYNC_SPLITS_REMOVED = 44; +export const SYNC_SPLITS_SEGMENTS = 45; +export const STREAMING_NEW_MESSAGE = 46; +export const SYNC_TASK_START = 47; +export const SYNC_TASK_EXECUTE = 48; +export const SYNC_TASK_STOP = 49; +export const IMPRESSIONS_TRACKER_SUCCESS = 50; +export const SETTINGS_SPLITS_FILTER = 51; -export const ERROR_0 = 300; -export const ERROR_2 = 302; -export const ERROR_CLIENT_LISTENER = 303; -export const ERROR_4 = 304; -export const ERROR_5 = 305; -export const ERROR_7 = 307; -export const ERROR_9 = 309; -export const ERROR_10 = 310; -export const ERROR_11 = 311; -export const ERROR_12 = 312; -export const ERROR_EVENT_TYPE_FORMAT = 314; -export const ERROR_NOT_PLAIN_OBJECT = 318; -export const ERROR_SIZE_EXCEEDED = 319; -export const ERROR_NOT_FINITE = 320; -export const ERROR_CLIENT_DESTROYED = 321; -export const ERROR_NULL = 322; -export const ERROR_TOO_LONG = 323; -export const ERROR_INVALID_KEY_OBJECT = 326; -export const ERROR_INVALID = 332; -export const ERROR_EMPTY = 333; -export const ERROR_EMPTY_ARRAY = 334; -export const ERROR_INVALID_IMPRESSIONS_MODE = 338; -export const ERROR_39 = 339; - -export const INFO_CLIENT_READY_FROM_CACHE = 100; -export const INFO_CLIENT_READY = 101; -export const INFO_2 = 102; -export const INFO_3 = 103; -export const INFO_4 = 104; -export const INFO_5 = 105; -export const INFO_6 = 106; -export const INFO_7 = 107; -export const INFO_8 = 108; -export const INFO_9 = 109; -export const INFO_10 = 110; -export const INFO_11 = 111; -export const INFO_12 = 112; -export const INFO_13 = 113; -export const INFO_14 = 114; -export const INFO_15 = 115; -export const INFO_16 = 116; -export const INFO_17 = 117; -export const INFO_18 = 118; -export const INFO_19 = 119; -export const INFO_20 = 120; -export const INFO_21 = 121; +export const CLIENT_READY_FROM_CACHE = 100; +export const CLIENT_READY = 101; +export const IMPRESSION = 102; +export const IMPRESSION_QUEUEING = 103; +export const NEW_SHARED_CLIENT = 104; +export const NEW_FACTORY = 105; +export const RETRIEVE_MANAGER = 106; +export const POLLING_SMART_PAUSING = 107; +export const POLLING_START = 108; +export const POLLING_STOP = 109; +export const SYNC_SPLITS_FETCH_RETRY = 110; +export const STREAMING_REFRESH_TOKEN = 111; +export const STREAMING_RECONNECT = 112; +export const STREAMING_CONNECTING = 113; +export const STREAMING_DISABLED = 114; +export const STREAMING_DISCONNECTING = 115; +export const SUBMITTERS_PUSH_FULL_EVENTS_QUEUE = 116; +export const SUBMITTERS_PUSH = 117; +export const SYNC_START_POLLING = 118; +export const SYNC_CONTINUE_POLLING = 119; +export const SYNC_STOP_POLLING = 120; +export const EVENTS_TRACKER_SUCCESS = 121; -export const WARN_ENGINE_INVALID_VALUE = 200; -export const WARN_ENGINE_NO_ATTRIBUTES = 201; -export const WARN_CLIENT_NO_LISTENER = 202; -export const WARN_4 = 204; -export const WARN_5 = 205; -export const WARN_6 = 206; -export const WARN_7 = 207; -export const WARN_8 = 208; -export const WARN_9 = 209; -export const WARN_10 = 210; -export const WARN_11 = 211; +export const ENGINE_VALUE_INVALID = 200; +export const ENGINE_VALUE_NO_ATTRIBUTES = 201; +export const CLIENT_NO_LISTENER = 202; +export const CLIENT_NOT_READY = 214; +export const SYNC_MYSEGMENTS_FETCH_RETRY = 204; +export const SYNC_SPLITS_FETCH_FAILS = 205; +export const STREAMING_PARSING_ERROR_FAILS = 206; +export const STREAMING_PARSING_MESSAGE_FAILS = 207; +export const STREAMING_FALLBACK = 208; +export const SUBMITTERS_PUSH_FAILS = 209; +export const SUBMITTERS_PUSH_RETRY = 210; export const WARN_SETTING_NULL = 212; export const WARN_TRIMMING_PROPERTIES = 213; -export const WARN_CLIENT_NOT_READY = 214; export const WARN_CONVERTING = 215; export const WARN_TRIMMING = 217; export const WARN_NOT_EXISTENT_SPLIT = 218; @@ -119,23 +94,48 @@ export const WARN_SPLITS_FILTER_INVALID = 223; export const WARN_SPLITS_FILTER_EMPTY = 224; export const WARN_STORAGE_INVALID = 225; export const WARN_API_KEY = 226; +export const ERROR_EVENTS_TRACKER = 211; + +export const ERROR_ENGINE_COMBINER_IFELSEIF = 300; +export const ERROR_LOGLEVEL_INVALID = 302; +export const ERROR_CLIENT_LISTENER = 303; +export const ERROR_MANAGER_NOT_AVAILABLE = 304; +export const ERROR_CLIENT_CANNOT_GET_READY = 305; +export const ERROR_SYNC_OFFLINE_LOADING = 307; +export const ERROR_STREAMING_SSE = 309; +export const ERROR_STREAMING_AUTH = 310; +export const ERROR_IMPRESSIONS_TRACKER = 311; +export const ERROR_IMPRESSIONS_LISTENER = 312; +export const ERROR_EVENT_TYPE_FORMAT = 314; +export const ERROR_NOT_PLAIN_OBJECT = 318; +export const ERROR_SIZE_EXCEEDED = 319; +export const ERROR_NOT_FINITE = 320; +export const ERROR_CLIENT_DESTROYED = 321; +export const ERROR_NULL = 322; +export const ERROR_TOO_LONG = 323; +export const ERROR_INVALID_KEY_OBJECT = 326; +export const ERROR_INVALID = 332; +export const ERROR_EMPTY = 333; +export const ERROR_EMPTY_ARRAY = 334; +export const ERROR_INVALID_IMPRESSIONS_MODE = 338; +export const ERROR_HTTP = 339; -// Log prefixes/tags/categories -export const SETTINGS_LB = 'settings'; -export const INSTANTIATION_LB = 'Factory instantiation'; -export const ENGINE_LB = 'engine'; -export const ENGINE_COMBINER_LB = ENGINE_LB + ':combiner: '; -export const ENGINE_MATCHER_LB = ENGINE_LB + ':matcher: '; -export const ENGINE_VALUE_LB = ENGINE_LB + ':value: '; -export const SYNC_LB = 'sync'; -export const SYNC_MANAGER_LB = SYNC_LB + ':sync-manager: '; -export const SYNC_OFFLINE_LB = SYNC_LB + ':offline: '; -export const SYNC_STREAMING_LB = SYNC_LB + ':streaming: '; -export const SYNC_SPLITS_LB = SYNC_LB + ':split-changes: '; -export const SYNC_SEGMENTS_LB = SYNC_LB + ':segment-changes: '; -export const SYNC_MYSEGMENTS_LB = SYNC_LB + ':my-segments: '; -export const SYNC_POLLING_LB = SYNC_LB + ':polling-manager: '; -export const SYNC_SUBMITTERS_LB = SYNC_LB + ':submitter: '; -export const IMPRESSIONS_TRACKER_LB = 'impressions-tracker: '; -export const EVENTS_TRACKER_LB = 'events-tracker: '; -export const CLEANUP_LB = 'cleanup: '; +// Log prefixes (a.k.a. tags or categories) +export const logPrefixSettings = 'settings'; +export const logPrefixInstantiation = 'Factory instantiation'; +export const logPrefixEngine = 'engine'; +export const logPrefixEngineCombiner = logPrefixEngine + ':combiner: '; +export const logPrefixEngineMatcher = logPrefixEngine + ':matcher: '; +export const logPrefixEngineValue = logPrefixEngine + ':value: '; +export const logPrefixSync = 'sync'; +export const logPrefixSyncManager = logPrefixSync + ':sync-manager: '; +export const logPrefixSyncOffline = logPrefixSync + ':offline: '; +export const logPrefixSyncStreaming = logPrefixSync + ':streaming: '; +export const logPrefixSyncSplits = logPrefixSync + ':split-changes: '; +export const logPrefixSyncSegments = logPrefixSync + ':segment-changes: '; +export const logPrefixSyncMysegments = logPrefixSync + ':my-segments: '; +export const logPrefixSyncPolling = logPrefixSync + ':polling-manager: '; +export const logPrefixSyncSubmitters = logPrefixSync + ':submitter: '; +export const logPrefixImpressionsTracker = 'impressions-tracker: '; +export const logPrefixEventsTracker = 'events-tracker: '; +export const logPrefixCleanup = 'cleanup: '; diff --git a/src/logger/messages/debug.ts b/src/logger/messages/debug.ts index c39fef55..af0098c8 100644 --- a/src/logger/messages/debug.ts +++ b/src/logger/messages/debug.ts @@ -1,50 +1,50 @@ -import { DEBUG_ENGINE_COMBINER_AND, DEBUG_1, DEBUG_2, DEBUG_3, DEBUG_4, DEBUG_5, DEBUG_6, DEBUG_7, DEBUG_8, DEBUG_9, DEBUG_10, DEBUG_11, DEBUG_12, DEBUG_13, DEBUG_14, DEBUG_15, DEBUG_16, DEBUG_17, DEBUG_18, DEBUG_19, DEBUG_20, DEBUG_21, DEBUG_22, DEBUG_23, DEBUG_24, DEBUG_25, DEBUG_32, DEBUG_33, DEBUG_36, DEBUG_42, DEBUG_43, DEBUG_44, DEBUG_45, DEBUG_46, DEBUG_47, DEBUG_48, DEBUG_49, DEBUG_50, DEBUG_SPLITS_FILTER, SETTINGS_LB, ENGINE_LB, ENGINE_COMBINER_LB, ENGINE_MATCHER_LB, ENGINE_VALUE_LB, SYNC_OFFLINE_LB, IMPRESSIONS_TRACKER_LB, SYNC_LB, SYNC_SPLITS_LB, SYNC_STREAMING_LB, CLEANUP_LB, DEBUG_26, DEBUG_27 } from '../constants'; +import { ENGINE_COMBINER_AND, ENGINE_COMBINER_IFELSEIF, ENGINE_COMBINER_IFELSEIF_NO_TREATMENT, ENGINE_BUCKET, ENGINE_MATCHER_ALL, ENGINE_MATCHER_BETWEEN, ENGINE_MATCHER_BOOLEAN, ENGINE_MATCHER_CONTAINS_ALL, ENGINE_MATCHER_CONTAINS_ANY, ENGINE_MATCHER_CONTAINS_STRING, ENGINE_MATCHER_DEPENDENCY, ENGINE_MATCHER_DEPENDENCY_PRE, ENGINE_MATCHER_EQUAL, ENGINE_MATCHER_EQUAL_TO_SET, ENGINE_MATCHER_ENDS_WITH, ENGINE_MATCHER_GREATER, ENGINE_MATCHER_LESS, ENGINE_MATCHER_PART_OF, ENGINE_MATCHER_SEGMENT_ASYNC, ENGINE_MATCHER_SEGMENT, ENGINE_MATCHER_STRING, ENGINE_MATCHER_STRING_INVALID, ENGINE_MATCHER_STARTS_WITH, ENGINE_MATCHER_WHITELIST, ENGINE_VALUE, ENGINE_SANITIZE, RETRIEVE_CLIENT_DEFAULT, RETRIEVE_CLIENT_EXISTING, SYNC_OFFLINE_DATA, SYNC_SPLITS_FETCH, SYNC_SPLITS_NEW, SYNC_SPLITS_REMOVED, SYNC_SPLITS_SEGMENTS, STREAMING_NEW_MESSAGE, SYNC_TASK_START, SYNC_TASK_EXECUTE, SYNC_TASK_STOP, IMPRESSIONS_TRACKER_SUCCESS, SETTINGS_SPLITS_FILTER, logPrefixSettings, logPrefixEngine, logPrefixEngineCombiner, logPrefixEngineMatcher, logPrefixEngineValue, logPrefixSyncOffline, logPrefixImpressionsTracker, logPrefixSync, logPrefixSyncSplits, logPrefixSyncStreaming, logPrefixCleanup, CLEANUP_REGISTERING, CLEANUP_DEREGISTERING } from '../constants'; import { codesInfo } from './info'; export const codesDebug: [number, string][] = codesInfo.concat([ // evaluator - [DEBUG_ENGINE_COMBINER_AND, ENGINE_COMBINER_LB + '[andCombiner] evaluates to %s'], - [DEBUG_1, ENGINE_COMBINER_LB + 'Treatment found: %s'], - [DEBUG_2, ENGINE_COMBINER_LB + 'All predicates evaluated, no treatment found.'], - [DEBUG_3, ENGINE_LB + ': using algo "murmur" bucket %s for key %s using seed %s - treatment %s'], - [DEBUG_4, ENGINE_MATCHER_LB + '[allMatcher] is always true'], - [DEBUG_5, ENGINE_MATCHER_LB + '[betweenMatcher] is %s between %s and %s? %s'], - [DEBUG_6, ENGINE_MATCHER_LB + '[booleanMatcher] %s === %s'], - [DEBUG_7, ENGINE_MATCHER_LB + '[containsAllMatcher] %s contains all elements of %s? %s'], - [DEBUG_8, ENGINE_MATCHER_LB + '[containsAnyMatcher] %s contains at least an element of %s? %s'], - [DEBUG_9, ENGINE_MATCHER_LB + '[containsStringMatcher] %s contains %s? %s'], - [DEBUG_10, ENGINE_MATCHER_LB + '[dependencyMatcher] Parent split "%s" evaluated to "%s" with label "%s". %s evaluated treatment is part of [%s] ? %s.'], - [DEBUG_11, ENGINE_MATCHER_LB + '[dependencyMatcher] will evaluate parent split: "%s" with key: %s %s'], - [DEBUG_12, ENGINE_MATCHER_LB + '[equalToMatcher] is %s equal to %s? %s'], - [DEBUG_13, ENGINE_MATCHER_LB + '[equalToSetMatcher] is %s equal to set %s? %s'], - [DEBUG_14, ENGINE_MATCHER_LB + '[endsWithMatcher] %s ends with %s? %s'], - [DEBUG_15, ENGINE_MATCHER_LB + '[greaterThanEqualMatcher] is %s greater than %s? %s'], - [DEBUG_16, ENGINE_MATCHER_LB + '[lessThanEqualMatcher] is %s less than %s? %s'], - [DEBUG_17, ENGINE_MATCHER_LB + '[partOfMatcher] %s is part of %s? %s'], - [DEBUG_18, ENGINE_MATCHER_LB + '[asyncSegmentMatcher] evaluated %s / %s => %s'], - [DEBUG_19, ENGINE_MATCHER_LB + '[segmentMatcher] evaluated %s / %s => %s'], - [DEBUG_20, ENGINE_MATCHER_LB + '[stringMatcher] does %s matches with %s? %s'], - [DEBUG_21, ENGINE_MATCHER_LB + '[stringMatcher] %s is an invalid regex'], - [DEBUG_22, ENGINE_MATCHER_LB + '[startsWithMatcher] %s starts with %s? %s'], - [DEBUG_23, ENGINE_MATCHER_LB + '[whitelistMatcher] evaluated %s in [%s] => %s'], - [DEBUG_24, ENGINE_VALUE_LB + 'Extracted attribute [%s], [%s] will be used for matching.'], - [DEBUG_25, ENGINE_LB + ':sanitize: Attempted to sanitize [%s] which should be of type [%s]. Sanitized and processed value => [%s]'], + [ENGINE_COMBINER_AND, logPrefixEngineCombiner + '[andCombiner] evaluates to %s'], + [ENGINE_COMBINER_IFELSEIF, logPrefixEngineCombiner + 'Treatment found: %s'], + [ENGINE_COMBINER_IFELSEIF_NO_TREATMENT, logPrefixEngineCombiner + 'All predicates evaluated, no treatment found.'], + [ENGINE_BUCKET, logPrefixEngine + ': using algo "murmur" bucket %s for key %s using seed %s - treatment %s'], + [ENGINE_MATCHER_ALL, logPrefixEngineMatcher + '[allMatcher] is always true'], + [ENGINE_MATCHER_BETWEEN, logPrefixEngineMatcher + '[betweenMatcher] is %s between %s and %s? %s'], + [ENGINE_MATCHER_BOOLEAN, logPrefixEngineMatcher + '[booleanMatcher] %s === %s'], + [ENGINE_MATCHER_CONTAINS_ALL, logPrefixEngineMatcher + '[containsAllMatcher] %s contains all elements of %s? %s'], + [ENGINE_MATCHER_CONTAINS_ANY, logPrefixEngineMatcher + '[containsAnyMatcher] %s contains at least an element of %s? %s'], + [ENGINE_MATCHER_CONTAINS_STRING, logPrefixEngineMatcher + '[containsStringMatcher] %s contains %s? %s'], + [ENGINE_MATCHER_DEPENDENCY, logPrefixEngineMatcher + '[dependencyMatcher] Parent split "%s" evaluated to "%s" with label "%s". %s evaluated treatment is part of [%s] ? %s.'], + [ENGINE_MATCHER_DEPENDENCY_PRE, logPrefixEngineMatcher + '[dependencyMatcher] will evaluate parent split: "%s" with key: %s %s'], + [ENGINE_MATCHER_EQUAL, logPrefixEngineMatcher + '[equalToMatcher] is %s equal to %s? %s'], + [ENGINE_MATCHER_EQUAL_TO_SET, logPrefixEngineMatcher + '[equalToSetMatcher] is %s equal to set %s? %s'], + [ENGINE_MATCHER_ENDS_WITH, logPrefixEngineMatcher + '[endsWithMatcher] %s ends with %s? %s'], + [ENGINE_MATCHER_GREATER, logPrefixEngineMatcher + '[greaterThanEqualMatcher] is %s greater than %s? %s'], + [ENGINE_MATCHER_LESS, logPrefixEngineMatcher + '[lessThanEqualMatcher] is %s less than %s? %s'], + [ENGINE_MATCHER_PART_OF, logPrefixEngineMatcher + '[partOfMatcher] %s is part of %s? %s'], + [ENGINE_MATCHER_SEGMENT_ASYNC, logPrefixEngineMatcher + '[asyncSegmentMatcher] evaluated %s / %s => %s'], + [ENGINE_MATCHER_SEGMENT, logPrefixEngineMatcher + '[segmentMatcher] evaluated %s / %s => %s'], + [ENGINE_MATCHER_STRING, logPrefixEngineMatcher + '[stringMatcher] does %s matches with %s? %s'], + [ENGINE_MATCHER_STRING_INVALID, logPrefixEngineMatcher + '[stringMatcher] %s is an invalid regex'], + [ENGINE_MATCHER_STARTS_WITH, logPrefixEngineMatcher + '[startsWithMatcher] %s starts with %s? %s'], + [ENGINE_MATCHER_WHITELIST, logPrefixEngineMatcher + '[whitelistMatcher] evaluated %s in [%s] => %s'], + [ENGINE_VALUE, logPrefixEngineValue + 'Extracted attribute [%s], [%s] will be used for matching.'], + [ENGINE_SANITIZE, logPrefixEngine + ':sanitize: Attempted to sanitize [%s] which should be of type [%s]. Sanitized and processed value => [%s]'], // SDK - [DEBUG_26, CLEANUP_LB + 'Registering cleanup handler %s'], - [DEBUG_27, CLEANUP_LB + 'Deregistering cleanup handler %s'], - [DEBUG_32, ' Retrieving default SDK client.'], - [DEBUG_33, ' Retrieving existing SDK client.'], + [CLEANUP_REGISTERING, logPrefixCleanup + 'Registering cleanup handler %s'], + [CLEANUP_DEREGISTERING, logPrefixCleanup + 'Deregistering cleanup handler %s'], + [RETRIEVE_CLIENT_DEFAULT, ' Retrieving default SDK client.'], + [RETRIEVE_CLIENT_EXISTING, ' Retrieving existing SDK client.'], // synchronizer - [DEBUG_36, SYNC_OFFLINE_LB + 'Splits data: \n%s'], - [DEBUG_42, SYNC_SPLITS_LB + 'Spin up split update using since = %s'], - [DEBUG_43, SYNC_SPLITS_LB + 'New splits %s'], - [DEBUG_44, SYNC_SPLITS_LB + 'Removed splits %s'], - [DEBUG_45, SYNC_SPLITS_LB + 'Segment names collected %s'], - [DEBUG_46, SYNC_STREAMING_LB + 'New SSE message received, with data: %s.'], - [DEBUG_47, SYNC_LB + ': Starting %s. Running each %s millis'], - [DEBUG_48, SYNC_LB + ': Running %s'], - [DEBUG_49, SYNC_LB + ': Stopping %s'], - [DEBUG_50, IMPRESSIONS_TRACKER_LB + 'Successfully stored %s impression%s.'], + [SYNC_OFFLINE_DATA, logPrefixSyncOffline + 'Splits data: \n%s'], + [SYNC_SPLITS_FETCH, logPrefixSyncSplits + 'Spin up split update using since = %s'], + [SYNC_SPLITS_NEW, logPrefixSyncSplits + 'New splits %s'], + [SYNC_SPLITS_REMOVED, logPrefixSyncSplits + 'Removed splits %s'], + [SYNC_SPLITS_SEGMENTS, logPrefixSyncSplits + 'Segment names collected %s'], + [STREAMING_NEW_MESSAGE, logPrefixSyncStreaming + 'New SSE message received, with data: %s.'], + [SYNC_TASK_START, logPrefixSync + ': Starting %s. Running each %s millis'], + [SYNC_TASK_EXECUTE, logPrefixSync + ': Running %s'], + [SYNC_TASK_STOP, logPrefixSync + ': Stopping %s'], + [IMPRESSIONS_TRACKER_SUCCESS, logPrefixImpressionsTracker + 'Successfully stored %s impression%s.'], // initialization / settings validation - [DEBUG_SPLITS_FILTER, SETTINGS_LB + ': splits filtering criteria is "%s".'] + [SETTINGS_SPLITS_FILTER, logPrefixSettings + ': splits filtering criteria is "%s".'] ]); diff --git a/src/logger/messages/error.ts b/src/logger/messages/error.ts index 48eaa32b..54e0c188 100644 --- a/src/logger/messages/error.ts +++ b/src/logger/messages/error.ts @@ -1,19 +1,19 @@ -import { ERROR_0, ERROR_2, ERROR_CLIENT_LISTENER, ERROR_4, ERROR_5, ERROR_7, ERROR_9, ERROR_10, ERROR_11, ERROR_12, ERROR_EVENT_TYPE_FORMAT, ERROR_NOT_PLAIN_OBJECT, ERROR_SIZE_EXCEEDED, ERROR_NOT_FINITE, ERROR_CLIENT_DESTROYED, ERROR_NULL, ERROR_TOO_LONG, ERROR_INVALID_KEY_OBJECT, ERROR_INVALID, ERROR_EMPTY, ERROR_EMPTY_ARRAY, ERROR_INVALID_IMPRESSIONS_MODE, ERROR_39, SETTINGS_LB, ENGINE_COMBINER_LB, SYNC_OFFLINE_LB, SYNC_STREAMING_LB, IMPRESSIONS_TRACKER_LB } from '../constants'; +import { ERROR_ENGINE_COMBINER_IFELSEIF, ERROR_LOGLEVEL_INVALID, ERROR_CLIENT_LISTENER, ERROR_MANAGER_NOT_AVAILABLE, ERROR_CLIENT_CANNOT_GET_READY, ERROR_SYNC_OFFLINE_LOADING, ERROR_STREAMING_SSE, ERROR_STREAMING_AUTH, ERROR_IMPRESSIONS_TRACKER, ERROR_IMPRESSIONS_LISTENER, ERROR_EVENT_TYPE_FORMAT, ERROR_NOT_PLAIN_OBJECT, ERROR_SIZE_EXCEEDED, ERROR_NOT_FINITE, ERROR_CLIENT_DESTROYED, ERROR_NULL, ERROR_TOO_LONG, ERROR_INVALID_KEY_OBJECT, ERROR_INVALID, ERROR_EMPTY, ERROR_EMPTY_ARRAY, ERROR_INVALID_IMPRESSIONS_MODE, ERROR_HTTP, logPrefixSettings, logPrefixEngineCombiner, logPrefixSyncOffline, logPrefixSyncStreaming, logPrefixImpressionsTracker } from '../constants'; export const codesError: [number, string][] = [ // evaluator - [ERROR_0, ENGINE_COMBINER_LB + 'Invalid Split, no valid rules found'], + [ERROR_ENGINE_COMBINER_IFELSEIF, logPrefixEngineCombiner + 'Invalid Split, no valid rules found'], // SDK - [ERROR_2, 'logger: Invalid Log Level - No changes to the logs will be applied.'], - [ERROR_4, ' Manager instance is not available.'], // @TODO remove if the manager is not pluggable - [ERROR_5, ' The SDK will not get ready. Reason: %s'], + [ERROR_LOGLEVEL_INVALID, 'logger: Invalid Log Level - No changes to the logs will be applied.'], + [ERROR_MANAGER_NOT_AVAILABLE, ' Manager instance is not available.'], // @TODO remove if the manager is not pluggable + [ERROR_CLIENT_CANNOT_GET_READY, ' The SDK will not get ready. Reason: %s'], // synchronizer - [ERROR_7, SYNC_OFFLINE_LB + 'There was an issue loading the mock Splits data, no changes will be applied to the current cache. %s'], - [ERROR_9, SYNC_STREAMING_LB + 'Fail to connect to streaming, with error message: %s'], - [ERROR_10, SYNC_STREAMING_LB + 'Failed to authenticate for streaming. Error: "%s".'], - [ERROR_11, IMPRESSIONS_TRACKER_LB + 'Could not store impressions bulk with %s impression%s. Error: %s'], - [ERROR_12, IMPRESSIONS_TRACKER_LB + 'Impression listener logImpression method threw: %s.'], - [ERROR_39, ' Response status is not OK. Status: %s. URL: %s. Message: %s'], + [ERROR_SYNC_OFFLINE_LOADING, logPrefixSyncOffline + 'There was an issue loading the mock Splits data, no changes will be applied to the current cache. %s'], + [ERROR_STREAMING_SSE, logPrefixSyncStreaming + 'Fail to connect to streaming, with error message: %s'], + [ERROR_STREAMING_AUTH, logPrefixSyncStreaming + 'Failed to authenticate for streaming. Error: "%s".'], + [ERROR_IMPRESSIONS_TRACKER, logPrefixImpressionsTracker + 'Could not store impressions bulk with %s impression%s. Error: %s'], + [ERROR_IMPRESSIONS_LISTENER, logPrefixImpressionsTracker + 'Impression listener logImpression method threw: %s.'], + [ERROR_HTTP, ' Response status is not OK. Status: %s. URL: %s. Message: %s'], // client status [ERROR_CLIENT_LISTENER, 'A listener was added for %s on the SDK, which has already fired and won\'t be emitted again. The callback won\'t be executed.'], [ERROR_CLIENT_DESTROYED, '%s: Client has already been destroyed - no calls possible.'], @@ -29,5 +29,5 @@ export const codesError: [number, string][] = [ [ERROR_EMPTY, '%s: you passed an empty %s. It must be a non-empty string.'], [ERROR_EMPTY_ARRAY, '%s: %s must be a non-empty array.'], // initialization / settings validation - [ERROR_INVALID_IMPRESSIONS_MODE, SETTINGS_LB + ': you passed an invalid "impressionsMode". It should be one of the following values: %s. Defaulting to "%s" mode.'], + [ERROR_INVALID_IMPRESSIONS_MODE, logPrefixSettings + ': you passed an invalid "impressionsMode". It should be one of the following values: %s. Defaulting to "%s" mode.'], ]; diff --git a/src/logger/messages/info.ts b/src/logger/messages/info.ts index 16f542c6..9a9c237e 100644 --- a/src/logger/messages/info.ts +++ b/src/logger/messages/info.ts @@ -1,32 +1,32 @@ -import { INFO_CLIENT_READY_FROM_CACHE, INFO_CLIENT_READY, INFO_2, INFO_3, INFO_4, INFO_5, INFO_6, INFO_7, INFO_8, INFO_9, INFO_10, INFO_11, INFO_12, INFO_13, INFO_14, INFO_15, INFO_16, INFO_17, INFO_18, INFO_19, INFO_20, INFO_21, EVENTS_TRACKER_LB, SYNC_MANAGER_LB, SYNC_POLLING_LB, SYNC_SPLITS_LB, SYNC_STREAMING_LB, SYNC_SUBMITTERS_LB, IMPRESSIONS_TRACKER_LB } from '../constants'; +import { CLIENT_READY_FROM_CACHE, CLIENT_READY, IMPRESSION, IMPRESSION_QUEUEING, NEW_SHARED_CLIENT, NEW_FACTORY, RETRIEVE_MANAGER, POLLING_SMART_PAUSING, POLLING_START, POLLING_STOP, SYNC_SPLITS_FETCH_RETRY, STREAMING_REFRESH_TOKEN, STREAMING_RECONNECT, STREAMING_CONNECTING, STREAMING_DISABLED, STREAMING_DISCONNECTING, SUBMITTERS_PUSH_FULL_EVENTS_QUEUE, SUBMITTERS_PUSH, SYNC_START_POLLING, SYNC_CONTINUE_POLLING, SYNC_STOP_POLLING, EVENTS_TRACKER_SUCCESS, logPrefixEventsTracker, logPrefixSyncManager, logPrefixSyncPolling, logPrefixSyncSplits, logPrefixSyncStreaming, logPrefixSyncSubmitters, logPrefixImpressionsTracker } from '../constants'; import { codesWarn } from './warn'; const READY_MSG = 'Split SDK is ready'; export const codesInfo: [number, string][] = codesWarn.concat([ // client status - [INFO_CLIENT_READY_FROM_CACHE, READY_MSG + ' from cache'], - [INFO_CLIENT_READY, READY_MSG], + [CLIENT_READY_FROM_CACHE, READY_MSG + ' from cache'], + [CLIENT_READY, READY_MSG], // SDK - [INFO_2, IMPRESSIONS_TRACKER_LB +'Split: %s. Key: %s. Evaluation: %s. Label: %s'], - [INFO_3, IMPRESSIONS_TRACKER_LB +'Queueing corresponding impression.'], - [INFO_4, ' New shared client instance created.'], - [INFO_5, ' New Split SDK instance created.'], - [INFO_6, ' Manager instance retrieved.'], - [INFO_21, EVENTS_TRACKER_LB + 'Successfully qeued %s'], + [IMPRESSION, logPrefixImpressionsTracker +'Split: %s. Key: %s. Evaluation: %s. Label: %s'], + [IMPRESSION_QUEUEING, logPrefixImpressionsTracker +'Queueing corresponding impression.'], + [NEW_SHARED_CLIENT, ' New shared client instance created.'], + [NEW_FACTORY, ' New Split SDK instance created.'], + [RETRIEVE_MANAGER, ' Manager instance retrieved.'], + [EVENTS_TRACKER_SUCCESS, logPrefixEventsTracker + 'Successfully qeued %s'], // synchronizer - [INFO_7, SYNC_POLLING_LB + 'Turning segments data polling %s.'], - [INFO_8, SYNC_POLLING_LB + 'Starting polling'], - [INFO_9, SYNC_POLLING_LB + 'Stopping polling'], - [INFO_10, SYNC_SPLITS_LB + 'Retrying download of splits #%s. Reason: %s'], - [INFO_16, SYNC_SUBMITTERS_LB + 'Flushing full events queue and reseting timer.'], - [INFO_17, SYNC_SUBMITTERS_LB + 'Pushing %s %s.'], - [INFO_11, SYNC_STREAMING_LB + 'Refreshing streaming token in %s seconds.'], - [INFO_12, SYNC_STREAMING_LB + 'Attempting to reconnect in %s seconds.'], - [INFO_13, SYNC_STREAMING_LB + 'Connecting to streaming.'], - [INFO_14, SYNC_STREAMING_LB + 'Streaming is disabled for given Api key. Switching to polling mode.'], - [INFO_15, SYNC_STREAMING_LB + 'Disconnecting from streaming.'], - [INFO_18, SYNC_MANAGER_LB + 'Streaming not available. Starting polling.'], - [INFO_19, SYNC_MANAGER_LB + 'Streaming couldn\'t connect. Continue polling.'], - [INFO_20, SYNC_MANAGER_LB + 'Streaming (re)connected. Syncing and stopping polling.'], + [POLLING_SMART_PAUSING, logPrefixSyncPolling + 'Turning segments data polling %s.'], + [POLLING_START, logPrefixSyncPolling + 'Starting polling'], + [POLLING_STOP, logPrefixSyncPolling + 'Stopping polling'], + [SYNC_SPLITS_FETCH_RETRY, logPrefixSyncSplits + 'Retrying download of splits #%s. Reason: %s'], + [SUBMITTERS_PUSH_FULL_EVENTS_QUEUE, logPrefixSyncSubmitters + 'Flushing full events queue and reseting timer.'], + [SUBMITTERS_PUSH, logPrefixSyncSubmitters + 'Pushing %s %s.'], + [STREAMING_REFRESH_TOKEN, logPrefixSyncStreaming + 'Refreshing streaming token in %s seconds.'], + [STREAMING_RECONNECT, logPrefixSyncStreaming + 'Attempting to reconnect in %s seconds.'], + [STREAMING_CONNECTING, logPrefixSyncStreaming + 'Connecting to streaming.'], + [STREAMING_DISABLED, logPrefixSyncStreaming + 'Streaming is disabled for given Api key. Switching to polling mode.'], + [STREAMING_DISCONNECTING, logPrefixSyncStreaming + 'Disconnecting from streaming.'], + [SYNC_START_POLLING, logPrefixSyncManager + 'Streaming not available. Starting polling.'], + [SYNC_CONTINUE_POLLING, logPrefixSyncManager + 'Streaming couldn\'t connect. Continue polling.'], + [SYNC_STOP_POLLING, logPrefixSyncManager + 'Streaming (re)connected. Syncing and stopping polling.'], ]); diff --git a/src/logger/messages/warn.ts b/src/logger/messages/warn.ts index c3338be4..96d36127 100644 --- a/src/logger/messages/warn.ts +++ b/src/logger/messages/warn.ts @@ -1,23 +1,23 @@ -import { WARN_ENGINE_INVALID_VALUE, WARN_ENGINE_NO_ATTRIBUTES, WARN_CLIENT_NO_LISTENER, WARN_4, WARN_5, WARN_6, WARN_7, WARN_8, WARN_9, WARN_10, WARN_11, WARN_SETTING_NULL, WARN_TRIMMING_PROPERTIES, WARN_CLIENT_NOT_READY, WARN_CONVERTING, WARN_TRIMMING, WARN_NOT_EXISTENT_SPLIT, WARN_LOWERCASE_TRAFFIC_TYPE, WARN_NOT_EXISTENT_TT, WARN_INTEGRATION_INVALID, WARN_SPLITS_FILTER_IGNORED, WARN_SPLITS_FILTER_INVALID, WARN_SPLITS_FILTER_EMPTY, WARN_STORAGE_INVALID, WARN_API_KEY, SETTINGS_LB, ENGINE_VALUE_LB, EVENTS_TRACKER_LB, SYNC_MYSEGMENTS_LB, SYNC_SPLITS_LB, SYNC_STREAMING_LB, SYNC_SUBMITTERS_LB } from '../constants'; +import { ENGINE_VALUE_INVALID, ENGINE_VALUE_NO_ATTRIBUTES, CLIENT_NO_LISTENER, SYNC_MYSEGMENTS_FETCH_RETRY, SYNC_SPLITS_FETCH_FAILS, STREAMING_PARSING_ERROR_FAILS, STREAMING_PARSING_MESSAGE_FAILS, STREAMING_FALLBACK, SUBMITTERS_PUSH_FAILS, SUBMITTERS_PUSH_RETRY, ERROR_EVENTS_TRACKER, WARN_SETTING_NULL, WARN_TRIMMING_PROPERTIES, CLIENT_NOT_READY, WARN_CONVERTING, WARN_TRIMMING, WARN_NOT_EXISTENT_SPLIT, WARN_LOWERCASE_TRAFFIC_TYPE, WARN_NOT_EXISTENT_TT, WARN_INTEGRATION_INVALID, WARN_SPLITS_FILTER_IGNORED, WARN_SPLITS_FILTER_INVALID, WARN_SPLITS_FILTER_EMPTY, WARN_STORAGE_INVALID, WARN_API_KEY, logPrefixSettings, logPrefixEngineValue, logPrefixEventsTracker, logPrefixSyncMysegments, logPrefixSyncSplits, logPrefixSyncStreaming, logPrefixSyncSubmitters } from '../constants'; import { codesError } from './error'; export const codesWarn: [number, string][] = codesError.concat([ // evaluator - [WARN_ENGINE_INVALID_VALUE, ENGINE_VALUE_LB + 'Value %s doesn\'t match with expected type.'], - [WARN_ENGINE_NO_ATTRIBUTES, ENGINE_VALUE_LB + 'Defined attribute [%s], no attributes received.'], + [ENGINE_VALUE_INVALID, logPrefixEngineValue + 'Value %s doesn\'t match with expected type.'], + [ENGINE_VALUE_NO_ATTRIBUTES, logPrefixEngineValue + 'Defined attribute [%s], no attributes received.'], // synchronizer - [WARN_4, SYNC_MYSEGMENTS_LB + 'Retrying download of segments #%s. Reason: %s'], - [WARN_5, SYNC_SPLITS_LB + 'Error while doing fetch of Splits. %s'], - [WARN_6, SYNC_STREAMING_LB + 'Error parsing SSE error notification: %s'], - [WARN_7, SYNC_STREAMING_LB + 'Error parsing new SSE message notification: %s'], - [WARN_8, SYNC_STREAMING_LB + 'Falling back to polling mode. Reason: %s'], - [WARN_9, SYNC_SUBMITTERS_LB + 'Droping %s %s after retry. Reason: %s.'], - [WARN_10, SYNC_SUBMITTERS_LB + 'Failed to push %s %s, keeping data to retry on next iteration. Reason: %s.'], + [SYNC_MYSEGMENTS_FETCH_RETRY, logPrefixSyncMysegments + 'Retrying download of segments #%s. Reason: %s'], + [SYNC_SPLITS_FETCH_FAILS, logPrefixSyncSplits + 'Error while doing fetch of Splits. %s'], + [STREAMING_PARSING_ERROR_FAILS, logPrefixSyncStreaming + 'Error parsing SSE error notification: %s'], + [STREAMING_PARSING_MESSAGE_FAILS, logPrefixSyncStreaming + 'Error parsing new SSE message notification: %s'], + [STREAMING_FALLBACK, logPrefixSyncStreaming + 'Falling back to polling mode. Reason: %s'], + [SUBMITTERS_PUSH_FAILS, logPrefixSyncSubmitters + 'Droping %s %s after retry. Reason: %s.'], + [SUBMITTERS_PUSH_RETRY, logPrefixSyncSubmitters + 'Failed to push %s %s, keeping data to retry on next iteration. Reason: %s.'], // SDK - [WARN_11, EVENTS_TRACKER_LB + 'Failed to queue %s'], + [ERROR_EVENTS_TRACKER, logPrefixEventsTracker + 'Failed to queue %s'], // client status - [WARN_CLIENT_NOT_READY, '%s: the SDK is not ready, results may be incorrect. Make sure to wait for SDK readiness before using this method.'], - [WARN_CLIENT_NO_LISTENER, 'No listeners for SDK Readiness detected. Incorrect control treatments could have been logged if you called getTreatment/s while the SDK was not yet ready.'], + [CLIENT_NOT_READY, '%s: the SDK is not ready, results may be incorrect. Make sure to wait for SDK readiness before using this method.'], + [CLIENT_NO_LISTENER, 'No listeners for SDK Readiness detected. Incorrect control treatments could have been logged if you called getTreatment/s while the SDK was not yet ready.'], // input validation [WARN_SETTING_NULL, '%s: Property "%s" is of invalid type. Setting value to null.'], [WARN_TRIMMING_PROPERTIES, '%s: Event has more than 300 properties. Some of them will be trimmed when processed.'], @@ -27,10 +27,10 @@ export const codesWarn: [number, string][] = codesError.concat([ [WARN_LOWERCASE_TRAFFIC_TYPE, '%s: traffic_type_name should be all lowercase - converting string to lowercase.'], [WARN_NOT_EXISTENT_TT, '%s: traffic type "%s" does not have any corresponding split in this environment, make sure you\'re tracking your events to a valid traffic type defined in the web console.'], // initialization / settings validation - [WARN_INTEGRATION_INVALID, SETTINGS_LB+': %s integration %s at settings %s invalid. %s'], - [WARN_SPLITS_FILTER_IGNORED, SETTINGS_LB+': split filters have been configured but will have no effect if mode is not "%s", since synchronization is being deferred to an external tool.'], - [WARN_SPLITS_FILTER_INVALID, SETTINGS_LB+': split filter at position %s is invalid. It must be an object with a valid filter type ("byName" or "byPrefix") and a list of "values".'], - [WARN_SPLITS_FILTER_EMPTY, SETTINGS_LB+': splitFilters configuration must be a non-empty array of filter objects.'], - [WARN_STORAGE_INVALID, SETTINGS_LB+': The provided storage is invalid. Fallbacking into default MEMORY storage'], - [WARN_API_KEY, SETTINGS_LB+': You already have %s. We recommend keeping only one instance of the factory at all times (Singleton pattern) and reusing it throughout your application'] + [WARN_INTEGRATION_INVALID, logPrefixSettings+': %s integration %s at settings %s invalid. %s'], + [WARN_SPLITS_FILTER_IGNORED, logPrefixSettings+': split filters have been configured but will have no effect if mode is not "%s", since synchronization is being deferred to an external tool.'], + [WARN_SPLITS_FILTER_INVALID, logPrefixSettings+': split filter at position %s is invalid. It must be an object with a valid filter type ("byName" or "byPrefix") and a list of "values".'], + [WARN_SPLITS_FILTER_EMPTY, logPrefixSettings+': splitFilters configuration must be a non-empty array of filter objects.'], + [WARN_STORAGE_INVALID, logPrefixSettings+': The provided storage is invalid. Fallbacking into default MEMORY storage'], + [WARN_API_KEY, logPrefixSettings+': You already have %s. We recommend keeping only one instance of the factory at all times (Singleton pattern) and reusing it throughout your application'] ]); diff --git a/src/logger/sdkLogger.ts b/src/logger/sdkLogger.ts index 32840ea5..41c3635a 100644 --- a/src/logger/sdkLogger.ts +++ b/src/logger/sdkLogger.ts @@ -1,7 +1,7 @@ import { LogLevels, isLogLevelString } from './index'; import { ILoggerAPI } from '../types'; import { ILogger } from './types'; -import { ERROR_2 } from './constants'; +import { ERROR_LOGLEVEL_INVALID } from './constants'; /** * The public Logger utility API exposed via SplitFactory, used to update the log level. @@ -14,7 +14,7 @@ export function createLoggerAPI(log: ILogger): ILoggerAPI { if (isLogLevelString(logLevel)) { log.setLogLevel(logLevel); } else { - log.error(ERROR_2); + log.error(ERROR_LOGLEVEL_INVALID); } } diff --git a/src/readiness/__tests__/sdkReadinessManager.spec.ts b/src/readiness/__tests__/sdkReadinessManager.spec.ts index cde58e8f..ca032224 100644 --- a/src/readiness/__tests__/sdkReadinessManager.spec.ts +++ b/src/readiness/__tests__/sdkReadinessManager.spec.ts @@ -4,7 +4,7 @@ import { IEventEmitter } from '../../types'; import { SDK_READY, SDK_READY_FROM_CACHE, SDK_READY_TIMED_OUT, SDK_UPDATE } from '../constants'; import sdkReadinessManagerFactory from '../sdkReadinessManager'; import { IReadinessManager } from '../types'; -import { ERROR_CLIENT_LISTENER, INFO_CLIENT_READY_FROM_CACHE, INFO_CLIENT_READY, WARN_CLIENT_NO_LISTENER } from '../../logger/constants'; +import { ERROR_CLIENT_LISTENER, CLIENT_READY_FROM_CACHE, CLIENT_READY, CLIENT_NO_LISTENER } from '../../logger/constants'; const EventEmitterMock = jest.fn(() => ({ on: jest.fn(), @@ -82,7 +82,7 @@ describe('SDK Readiness Manager - Event emitter', () => { const readyFromCacheEventCB = gateMock.once.mock.calls[2][1]; readyFromCacheEventCB(); expect(loggerMock.info.mock.calls.length).toBe(1); // If the SDK_READY_FROM_CACHE event fires, we get a info message. - expect(loggerMock.info).toBeCalledWith(INFO_CLIENT_READY_FROM_CACHE); // Telling us the SDK is ready to be used with data from cache. + expect(loggerMock.info).toBeCalledWith(CLIENT_READY_FROM_CACHE); // Telling us the SDK is ready to be used with data from cache. }); test('The event callbacks should work as expected - SDK_READY emits with no callbacks', () => { @@ -94,10 +94,10 @@ describe('SDK Readiness Manager - Event emitter', () => { emitReadyEvent(sdkReadinessManager.readinessManager); expect(loggerMock.warn.mock.calls.length).toBe(1); // If the SDK_READY event fires and we have no callbacks for it (neither event nor ready promise) we get a warning. - expect(loggerMock.warn).toBeCalledWith(WARN_CLIENT_NO_LISTENER); // Telling us there were no listeners and evaluations before this point may have been incorrect. + expect(loggerMock.warn).toBeCalledWith(CLIENT_NO_LISTENER); // Telling us there were no listeners and evaluations before this point may have been incorrect. expect(loggerMock.info.mock.calls.length).toBe(1); // If the SDK_READY event fires, we get a info message. - expect(loggerMock.info).toBeCalledWith(INFO_CLIENT_READY); // Telling us the SDK is ready. + expect(loggerMock.info).toBeCalledWith(CLIENT_READY); // Telling us the SDK is ready. // Now it's marked as ready. addListenerCB('this event we do not care'); @@ -126,7 +126,7 @@ describe('SDK Readiness Manager - Event emitter', () => { expect(loggerMock.error.mock.calls.length).toBe(0); // As we had at least one listener, we get no errors. expect(loggerMock.info.mock.calls.length).toBe(1); // If the SDK_READY event fires, we get a info message. - expect(loggerMock.info).toBeCalledWith(INFO_CLIENT_READY); // Telling us the SDK is ready. + expect(loggerMock.info).toBeCalledWith(CLIENT_READY); // Telling us the SDK is ready. }); test('The event callbacks should work as expected - If we end up removing the listeners for SDK_READY, it behaves as if it had none', () => { @@ -146,7 +146,7 @@ describe('SDK Readiness Manager - Event emitter', () => { removeListenerCB(SDK_READY); emitReadyEvent(sdkReadinessManager.readinessManager); - expect(loggerMock.warn).toBeCalledWith(WARN_CLIENT_NO_LISTENER); // We get the warning. + expect(loggerMock.warn).toBeCalledWith(CLIENT_NO_LISTENER); // We get the warning. }); test('The event callbacks should work as expected - If we end up removing the listeners for SDK_READY, it behaves as if it had none', () => { @@ -272,7 +272,7 @@ describe('SDK Readiness Manager - Ready promise', () => { const readyEventCB = sdkReadinessManager.readinessManager.gate.once.mock.calls[0][1]; readyEventCB(); - expect(loggerMock.warn).toBeCalledWith(WARN_CLIENT_NO_LISTENER); // We would get the warning if the SDK get\'s ready before attaching any callbacks to ready promise. + expect(loggerMock.warn).toBeCalledWith(CLIENT_NO_LISTENER); // We would get the warning if the SDK get\'s ready before attaching any callbacks to ready promise. loggerMock.warn.mockClear(); readyPromise.then(() => { diff --git a/src/readiness/sdkReadinessManager.ts b/src/readiness/sdkReadinessManager.ts index f1ada0fa..07f8f284 100644 --- a/src/readiness/sdkReadinessManager.ts +++ b/src/readiness/sdkReadinessManager.ts @@ -5,7 +5,7 @@ import { ISdkReadinessManager } from './types'; import { IEventEmitter } from '../types'; import { SDK_READY, SDK_READY_TIMED_OUT, SDK_READY_FROM_CACHE, SDK_UPDATE } from './constants'; import { ILogger } from '../logger/types'; -import { ERROR_CLIENT_LISTENER, INFO_CLIENT_READY_FROM_CACHE, INFO_CLIENT_READY, WARN_CLIENT_NO_LISTENER } from '../logger/constants'; +import { ERROR_CLIENT_LISTENER, CLIENT_READY_FROM_CACHE, CLIENT_READY, CLIENT_NO_LISTENER } from '../logger/constants'; const NEW_LISTENER_EVENT = 'newListener'; const REMOVE_LISTENER_EVENT = 'removeListener'; @@ -46,7 +46,7 @@ export default function sdkReadinessManagerFactory( const readyPromise = generateReadyPromise(); readinessManager.gate.once(SDK_READY_FROM_CACHE, () => { - log.info(INFO_CLIENT_READY_FROM_CACHE); + log.info(CLIENT_READY_FROM_CACHE); }); // default onRejected handler, that just logs the error, if ready promise doesn't have one. @@ -57,9 +57,9 @@ export default function sdkReadinessManagerFactory( function generateReadyPromise() { const promise = promiseWrapper(new Promise((resolve, reject) => { readinessManager.gate.once(SDK_READY, () => { - log.info(INFO_CLIENT_READY); + log.info(CLIENT_READY); - if (readyCbCount === internalReadyCbCount && !promise.hasOnFulfilled()) log.warn(WARN_CLIENT_NO_LISTENER); + if (readyCbCount === internalReadyCbCount && !promise.hasOnFulfilled()) log.warn(CLIENT_NO_LISTENER); resolve(); }); readinessManager.gate.once(SDK_READY_TIMED_OUT, reject); diff --git a/src/sdkClient/client.ts b/src/sdkClient/client.ts index 0dfd6dd9..e9f178d8 100644 --- a/src/sdkClient/client.ts +++ b/src/sdkClient/client.ts @@ -8,7 +8,7 @@ import { CONTROL } from '../utils/constants'; import { IClientFactoryParams } from './types'; import { IEvaluationResult } from '../evaluator/types'; import { SplitIO, ImpressionDTO } from '../types'; -import { INFO_2, INFO_3 } from '../logger/constants'; +import { IMPRESSION, IMPRESSION_QUEUEING } from '../logger/constants'; /** @@ -75,10 +75,10 @@ export default function clientFactory(params: IClientFactoryParams): SplitIO.ICl } const { treatment, label, changeNumber, config = null } = evaluation; - log.info(INFO_2, [splitName, matchingKey, treatment, label]); + log.info(IMPRESSION, [splitName, matchingKey, treatment, label]); if (validateSplitExistance(log, readinessManager, splitName, label, invokingMethodName)) { - log.info(INFO_3); + log.info(IMPRESSION_QUEUEING); queue.push({ feature: splitName, keyName: matchingKey, diff --git a/src/sdkClient/sdkClientMethod.ts b/src/sdkClient/sdkClientMethod.ts index 9498d0f0..82d37435 100644 --- a/src/sdkClient/sdkClientMethod.ts +++ b/src/sdkClient/sdkClientMethod.ts @@ -1,7 +1,7 @@ import { ISdkClientFactoryParams } from './types'; import { SplitIO } from '../types'; import { sdkClientFactory } from './sdkClient'; -import { DEBUG_32 } from '../logger/constants'; +import { RETRIEVE_CLIENT_DEFAULT } from '../logger/constants'; /** * Factory of client method for server-side SDKs (ISDK and IAsyncSDK) @@ -15,7 +15,7 @@ export function sdkClientMethodFactory(params: ISdkClientFactoryParams): () => S throw new Error('Shared Client not supported by the storage mechanism. Create isolated instances instead.'); } - log.debug(DEBUG_32); + log.debug(RETRIEVE_CLIENT_DEFAULT); return clientInstance; }; } diff --git a/src/sdkClient/sdkClientMethodCS.ts b/src/sdkClient/sdkClientMethodCS.ts index 28ae2ac9..80089705 100644 --- a/src/sdkClient/sdkClientMethodCS.ts +++ b/src/sdkClient/sdkClientMethodCS.ts @@ -7,7 +7,7 @@ import { sdkClientFactory } from './sdkClient'; import { IStorageSyncCS } from '../storages/types'; import { ISyncManagerCS } from '../sync/types'; import objectAssign from 'object-assign'; -import { DEBUG_32, INFO_4, DEBUG_33 } from '../logger/constants'; +import { RETRIEVE_CLIENT_DEFAULT, NEW_SHARED_CLIENT, RETRIEVE_CLIENT_EXISTING } from '../logger/constants'; function buildInstanceId(key: SplitIO.SplitKey) { // @ts-ignore @@ -42,7 +42,7 @@ export function sdkClientMethodCSFactory(params: ISdkClientFactoryParams): (key? return function client(key?: SplitIO.SplitKey) { if (key === undefined) { - log.debug(DEBUG_32); + log.debug(RETRIEVE_CLIENT_DEFAULT); return mainClientInstance; } @@ -76,9 +76,9 @@ export function sdkClientMethodCSFactory(params: ISdkClientFactoryParams): (key? sharedSyncManager.start(); - log.info(INFO_4); + log.info(NEW_SHARED_CLIENT); } else { - log.debug(DEBUG_33); + log.debug(RETRIEVE_CLIENT_EXISTING); } return clientInstances[instanceId]; diff --git a/src/sdkClient/sdkClientMethodCSWithTT.ts b/src/sdkClient/sdkClientMethodCSWithTT.ts index 03f9caac..684f3a5b 100644 --- a/src/sdkClient/sdkClientMethodCSWithTT.ts +++ b/src/sdkClient/sdkClientMethodCSWithTT.ts @@ -8,7 +8,7 @@ import { sdkClientFactory } from './sdkClient'; import { IStorageSyncCS } from '../storages/types'; import { ISyncManagerCS } from '../sync/types'; import objectAssign from 'object-assign'; -import { DEBUG_32, INFO_4, DEBUG_33 } from '../logger/constants'; +import { RETRIEVE_CLIENT_DEFAULT, NEW_SHARED_CLIENT, RETRIEVE_CLIENT_EXISTING } from '../logger/constants'; function buildInstanceId(key: SplitIO.SplitKey, trafficType?: string) { // @ts-ignore @@ -49,7 +49,7 @@ export function sdkClientMethodCSFactory(params: ISdkClientFactoryParams): (key? return function client(key?: SplitIO.SplitKey, trafficType?: string) { if (key === undefined) { - log.debug(DEBUG_32); + log.debug(RETRIEVE_CLIENT_DEFAULT); return mainClientInstance; } @@ -91,9 +91,9 @@ export function sdkClientMethodCSFactory(params: ISdkClientFactoryParams): (key? sharedSyncManager.start(); - log.info(INFO_4); + log.info(NEW_SHARED_CLIENT); } else { - log.debug(DEBUG_33); + log.debug(RETRIEVE_CLIENT_EXISTING); } return clientInstances[instanceId]; diff --git a/src/sdkFactory/index.ts b/src/sdkFactory/index.ts index 4b80cabf..0b08ad5a 100644 --- a/src/sdkFactory/index.ts +++ b/src/sdkFactory/index.ts @@ -10,7 +10,7 @@ import { getMatching } from '../utils/key'; import { shouldBeOptimized } from '../trackers/impressionObserver/utils'; import { validateAndTrackApiKey } from '../utils/inputValidation/apiKey'; import { createLoggerAPI } from '../logger/sdkLogger'; -import { INFO_5, INFO_6, ERROR_4 } from '../logger/constants'; +import { NEW_FACTORY, RETRIEVE_MANAGER, ERROR_MANAGER_NOT_AVAILABLE } from '../logger/constants'; /** * Modular SDK factory @@ -78,7 +78,7 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO. syncManager && syncManager.start(); signalListener && signalListener.start(); - log.info(INFO_5); + log.info(NEW_FACTORY); return { // Split evaluation and event tracking engine @@ -87,8 +87,8 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO. // Manager API to explore available information // @ts-ignore manager() { - if (managerInstance) log.info(INFO_6); - else log.error(ERROR_4); + if (managerInstance) log.info(RETRIEVE_MANAGER); + else log.error(ERROR_MANAGER_NOT_AVAILABLE); return managerInstance; }, diff --git a/src/services/splitHttpClient.ts b/src/services/splitHttpClient.ts index 58a768d4..d19beb9c 100644 --- a/src/services/splitHttpClient.ts +++ b/src/services/splitHttpClient.ts @@ -3,7 +3,7 @@ import { SplitError, SplitNetworkError } from '../utils/lang/errors'; import objectAssign from 'object-assign'; import { IMetadata } from '../dtos/types'; import { ILogger } from '../logger/types'; -import { ERROR_39, ERROR_5 } from '../logger/constants'; +import { ERROR_HTTP, ERROR_CLIENT_CANNOT_GET_READY } from '../logger/constants'; const messageNoFetch = 'Global fetch API is not available.'; @@ -21,7 +21,7 @@ export function splitHttpClientFactory(log: ILogger, apikey: string, metadata: I const fetch = getFetch && getFetch(); // if fetch is not available, log Error - if (!fetch) log.error(ERROR_5, [messageNoFetch]); + if (!fetch) log.error(ERROR_CLIENT_CANNOT_GET_READY, [messageNoFetch]); const headers: Record = { 'Accept': 'application/json', @@ -66,7 +66,7 @@ export function splitHttpClientFactory(log: ILogger, apikey: string, metadata: I } if (!resp || resp.status !== 403) { // 403's log we'll be handled somewhere else. - log[logErrorsAsInfo ? 'info' : 'error'](ERROR_39, [resp ? resp.status : 'NO_STATUS', url, msg]); + log[logErrorsAsInfo ? 'info' : 'error'](ERROR_HTTP, [resp ? resp.status : 'NO_STATUS', url, msg]); } // passes `undefined` as statusCode if not an HTTP error (resp === undefined) diff --git a/src/sync/offline/syncTasks/fromObjectSyncTask.ts b/src/sync/offline/syncTasks/fromObjectSyncTask.ts index a3ad3273..66c51db1 100644 --- a/src/sync/offline/syncTasks/fromObjectSyncTask.ts +++ b/src/sync/offline/syncTasks/fromObjectSyncTask.ts @@ -8,7 +8,7 @@ import { ISyncTask } from '../../types'; import { ISettings } from '../../../types'; import { CONTROL } from '../../../utils/constants'; import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED } from '../../../readiness/constants'; -import { DEBUG_36, ERROR_7 } from '../../../logger/constants'; +import { SYNC_OFFLINE_DATA, ERROR_SYNC_OFFLINE_LOADING } from '../../../logger/constants'; /** * Offline equivalent of `splitChangesUpdaterFactory` @@ -30,11 +30,11 @@ export function fromObjectUpdaterFactory( splitsMock = splitsParser(settings); } catch (err) { loadError = err; - log.error(ERROR_7, [err]); + log.error(ERROR_SYNC_OFFLINE_LOADING, [err]); } if (!loadError && splitsMock) { - log.debug(DEBUG_36, [JSON.stringify(splitsMock)]); + log.debug(SYNC_OFFLINE_DATA, [JSON.stringify(splitsMock)]); forOwn(splitsMock, function (val, name) { splits.push([ diff --git a/src/sync/polling/pollingManagerCS.ts b/src/sync/polling/pollingManagerCS.ts index 3d4687c2..7fbbc747 100644 --- a/src/sync/polling/pollingManagerCS.ts +++ b/src/sync/polling/pollingManagerCS.ts @@ -8,7 +8,7 @@ import splitsSyncTaskFactory from './syncTasks/splitsSyncTask'; import { ISettings } from '../../types'; import { getMatching } from '../../utils/key'; import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED } from '../../readiness/constants'; -import { INFO_7, INFO_8, INFO_9 } from '../../logger/constants'; +import { POLLING_SMART_PAUSING, POLLING_START, POLLING_STOP } from '../../logger/constants'; /** * Expose start / stop mechanism for polling data from services. @@ -48,7 +48,7 @@ export default function pollingManagerCSFactory( if (!splitsSyncTask.isRunning()) return; // noop if not doing polling const splitsHaveSegments = storage.splits.usesSegments(); if (splitsHaveSegments !== mySegmentsSyncTask.isRunning()) { - log.info(INFO_7, [splitsHaveSegments ? 'ON' : 'OFF']); + log.info(POLLING_SMART_PAUSING, [splitsHaveSegments ? 'ON' : 'OFF']); if (splitsHaveSegments) { startMySegmentsSyncTasks(); } else { @@ -77,7 +77,7 @@ export default function pollingManagerCSFactory( // Start periodic fetching (polling) start() { - log.info(INFO_8); + log.info(POLLING_START); splitsSyncTask.start(); if (storage.splits.usesSegments()) startMySegmentsSyncTasks(); @@ -85,7 +85,7 @@ export default function pollingManagerCSFactory( // Stop periodic fetching (polling) stop() { - log.info(INFO_9); + log.info(POLLING_STOP); if (splitsSyncTask.isRunning()) splitsSyncTask.stop(); stopMySegmentsSyncTasks(); diff --git a/src/sync/polling/pollingManagerSS.ts b/src/sync/polling/pollingManagerSS.ts index f6cf4396..24b27600 100644 --- a/src/sync/polling/pollingManagerSS.ts +++ b/src/sync/polling/pollingManagerSS.ts @@ -6,7 +6,7 @@ import { ISplitApi } from '../../services/types'; import { ISettings } from '../../types'; import { IPollingManager, ISegmentsSyncTask, ISplitsSyncTask } from './types'; import thenable from '../../utils/promise/thenable'; -import { INFO_8, INFO_9, SYNC_POLLING_LB } from '../../logger/constants'; +import { POLLING_START, POLLING_STOP, logPrefixSyncPolling } from '../../logger/constants'; /** * Expose start / stop mechanism for pulling data from services. @@ -29,9 +29,9 @@ export default function pollingManagerSSFactory( // Start periodic fetching (polling) start() { - log.info(INFO_8); - log.debug(SYNC_POLLING_LB + `Splits will be refreshed each ${settings.scheduler.featuresRefreshRate} millis`); - log.debug(SYNC_POLLING_LB + `Segments will be refreshed each ${settings.scheduler.segmentsRefreshRate} millis`); + log.info(POLLING_START); + log.debug(logPrefixSyncPolling + `Splits will be refreshed each ${settings.scheduler.featuresRefreshRate} millis`); + log.debug(logPrefixSyncPolling + `Segments will be refreshed each ${settings.scheduler.segmentsRefreshRate} millis`); const startingUp = splitsSyncTask.start(); if (thenable(startingUp)) { @@ -43,7 +43,7 @@ export default function pollingManagerSSFactory( // Stop periodic fetching (polling) stop() { - log.info(INFO_9); + log.info(POLLING_STOP); if (splitsSyncTask.isRunning()) splitsSyncTask.stop(); if (segmentsSyncTask.isRunning()) segmentsSyncTask.stop(); diff --git a/src/sync/polling/syncTasks/mySegmentsSyncTask.ts b/src/sync/polling/syncTasks/mySegmentsSyncTask.ts index 9bc3aeb8..6b19166d 100644 --- a/src/sync/polling/syncTasks/mySegmentsSyncTask.ts +++ b/src/sync/polling/syncTasks/mySegmentsSyncTask.ts @@ -10,7 +10,7 @@ import mySegmentsFetcherFactory from '../fetchers/mySegmentsFetcher'; import { ISettings } from '../../../types'; import { SDK_SEGMENTS_ARRIVED } from '../../../readiness/constants'; import { ILogger } from '../../../logger/types'; -import { WARN_4 } from '../../../logger/constants'; +import { SYNC_MYSEGMENTS_FETCH_RETRY } from '../../../logger/constants'; type IMySegmentsUpdater = (segmentList?: string[], noCache?: boolean) => Promise @@ -74,7 +74,7 @@ function mySegmentsUpdaterFactory( if (startingUp && retriesOnFailureBeforeReady > retry) { retry += 1; - log.warn(WARN_4, [retry, error]); + log.warn(SYNC_MYSEGMENTS_FETCH_RETRY, [retry, error]); return _mySegmentsUpdater(retry); // no need to forward `segmentList` and `noCache` params } else { startingUp = false; diff --git a/src/sync/polling/syncTasks/segmentsSyncTask.ts b/src/sync/polling/syncTasks/segmentsSyncTask.ts index bf131d5c..4d0d400b 100644 --- a/src/sync/polling/syncTasks/segmentsSyncTask.ts +++ b/src/sync/polling/syncTasks/segmentsSyncTask.ts @@ -11,7 +11,7 @@ import { IFetchSegmentChanges } from '../../../services/types'; import { ISettings } from '../../../types'; import { SDK_SEGMENTS_ARRIVED } from '../../../readiness/constants'; import { ILogger } from '../../../logger/types'; -import { INSTANTIATION_LB, SYNC_SEGMENTS_LB } from '../../../logger/constants'; +import { logPrefixInstantiation, logPrefixSyncSegments } from '../../../logger/constants'; type ISegmentChangesUpdater = (segmentNames?: string[], noCache?: boolean, fetchOnlyNew?: boolean) => Promise @@ -48,7 +48,7 @@ function segmentChangesUpdaterFactory( * This param is used by SplitUpdateWorker on server-side SDK, to fetch new registered segments on SPLIT_UPDATE notifications. */ return function segmentChangesUpdater(segmentNames?: string[], noCache?: boolean, fetchOnlyNew?: boolean) { - log.debug(SYNC_SEGMENTS_LB + 'Started segments update'); + log.debug(logPrefixSyncSegments + 'Started segments update'); // If not a segment name provided, read list of available segments names to be updated. let segments = segmentNames ? segmentNames : segmentsCache.getRegisteredSegments(); @@ -61,7 +61,7 @@ function segmentChangesUpdaterFactory( const segmentName = segments[index]; const since = segmentsCache.getChangeNumber(segmentName); - log.debug(SYNC_SEGMENTS_LB + `Processing segment ${segmentName}`); + log.debug(logPrefixSyncSegments + `Processing segment ${segmentName}`); updaters.push(segmentChangesFetcher(since, segmentName, noCache, _promiseDecorator).then(function (changes) { let changeNumber = -1; @@ -73,7 +73,7 @@ function segmentChangesUpdaterFactory( changeNumber = x.till; } - log.debug(SYNC_SEGMENTS_LB + `Processed ${segmentName} with till = ${x.till}. Added: ${x.added.length}. Removed: ${x.removed.length}`); + log.debug(logPrefixSyncSegments + `Processed ${segmentName} with till = ${x.till}. Added: ${x.added.length}. Removed: ${x.removed.length}`); }); return changeNumber; @@ -97,7 +97,7 @@ function segmentChangesUpdaterFactory( if (error.statusCode === 403) { // @TODO although factory status is destroyed, synchronization is not stopped readiness.destroy(); - log.error(INSTANTIATION_LB + ': you passed a client-side type authorizationKey, please grab an Api Key from the Split web console that is of type Server-side.'); + log.error(logPrefixInstantiation + ': you passed a client-side type authorizationKey, please grab an Api Key from the Split web console that is of type Server-side.'); } return false; diff --git a/src/sync/polling/syncTasks/splitsSyncTask.ts b/src/sync/polling/syncTasks/splitsSyncTask.ts index 81bd23fc..a69e579a 100644 --- a/src/sync/polling/syncTasks/splitsSyncTask.ts +++ b/src/sync/polling/syncTasks/splitsSyncTask.ts @@ -13,7 +13,7 @@ import thenable from '../../../utils/promise/thenable'; import { ISettings } from '../../../types'; import { SDK_SPLITS_ARRIVED, SDK_SPLITS_CACHE_LOADED } from '../../../readiness/constants'; import { ILogger } from '../../../logger/types'; -import { DEBUG_42, DEBUG_43, DEBUG_44, DEBUG_45, WARN_5, INFO_10 } from '../../../logger/constants'; +import { SYNC_SPLITS_FETCH, SYNC_SPLITS_NEW, SYNC_SPLITS_REMOVED, SYNC_SPLITS_SEGMENTS, SYNC_SPLITS_FETCH_FAILS, SYNC_SPLITS_FETCH_RETRY } from '../../../logger/constants'; type ISplitChangesUpdater = (noCache?: boolean) => Promise @@ -116,7 +116,7 @@ export function splitChangesUpdaterFactory( * @param {number} retry current number of retry attemps */ function _splitChangesUpdater(since: number, retry = 0): Promise { - log.debug(DEBUG_42, [since]); + log.debug(SYNC_SPLITS_FETCH, [since]); const fetcherPromise = splitChangesFetcher(since, noCache, _promiseDecorator) .then((splitChanges: ISplitChangesResponse) => { @@ -124,9 +124,9 @@ export function splitChangesUpdaterFactory( const mutation = computeSplitsMutation(splitChanges.splits); - log.debug(DEBUG_43, [mutation.added.length]); - log.debug(DEBUG_44, [mutation.removed.length]); - log.debug(DEBUG_45, [mutation.segments.length]); + log.debug(SYNC_SPLITS_NEW, [mutation.added.length]); + log.debug(SYNC_SPLITS_REMOVED, [mutation.removed.length]); + log.debug(SYNC_SPLITS_SEGMENTS, [mutation.segments.length]); // Write into storage // @TODO if allowing custom storages, wrap errors as SplitErrors to distinguish from user callback errors @@ -152,11 +152,11 @@ export function splitChangesUpdaterFactory( startingUp = false; // Stop retrying. } - log.warn(WARN_5, [error]); + log.warn(SYNC_SPLITS_FETCH_FAILS, [error]); if (startingUp && retriesOnFailureBeforeReady > retry) { retry += 1; - log.info(INFO_10, [retry, error]); + log.info(SYNC_SPLITS_FETCH_RETRY, [retry, error]); return _splitChangesUpdater(since, retry); } else { startingUp = false; diff --git a/src/sync/streaming/SSEHandler/index.ts b/src/sync/streaming/SSEHandler/index.ts index c1e5d5dc..716564d8 100644 --- a/src/sync/streaming/SSEHandler/index.ts +++ b/src/sync/streaming/SSEHandler/index.ts @@ -5,7 +5,7 @@ import { IPushEventEmitter } from '../types'; import { ISseEventHandler } from '../SSEClient/types'; import { INotificationError } from './types'; import { ILogger } from '../../../logger/types'; -import { WARN_6, ERROR_9, WARN_7, DEBUG_46 } from '../../../logger/constants'; +import { STREAMING_PARSING_ERROR_FAILS, ERROR_STREAMING_SSE, STREAMING_PARSING_MESSAGE_FAILS, STREAMING_NEW_MESSAGE } from '../../../logger/constants'; function isRetryableError(error: INotificationError) { if (error.parsedData && error.parsedData.code) { @@ -40,11 +40,11 @@ export default function SSEHandlerFactory(log: ILogger, pushEmitter: IPushEventE try { errorWithParsedData = errorParser(error); } catch (err) { - log.warn(WARN_6, [err]); + log.warn(STREAMING_PARSING_ERROR_FAILS, [err]); } let errorMessage = errorWithParsedData.parsedData && errorWithParsedData.parsedData.message; - log.error(ERROR_9, [errorMessage]); + log.error(ERROR_STREAMING_SSE, [errorMessage]); if (isRetryableError(errorWithParsedData)) { pushEmitter.emit(PUSH_RETRYABLE_ERROR); @@ -59,12 +59,12 @@ export default function SSEHandlerFactory(log: ILogger, pushEmitter: IPushEventE try { messageWithParsedData = messageParser(message); } catch (err) { - log.warn(WARN_7, [err]); + log.warn(STREAMING_PARSING_MESSAGE_FAILS, [err]); return; } const { parsedData, data, channel, timestamp } = messageWithParsedData; - log.debug(DEBUG_46, [data]); + log.debug(STREAMING_NEW_MESSAGE, [data]); // we only handle update events if streaming is up. if (!notificationKeeper.isStreamingUp() && parsedData.type !== OCCUPANCY && parsedData.type !== CONTROL) diff --git a/src/sync/streaming/pushManager.ts b/src/sync/streaming/pushManager.ts index a3e9ef22..0e7f1559 100644 --- a/src/sync/streaming/pushManager.ts +++ b/src/sync/streaming/pushManager.ts @@ -18,7 +18,7 @@ import { ISettings } from '../../types'; import { getMatching } from '../../utils/key'; import { MY_SEGMENTS_UPDATE, PUSH_NONRETRYABLE_ERROR, PUSH_SUBSYSTEM_DOWN, SECONDS_BEFORE_EXPIRATION, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, PUSH_RETRYABLE_ERROR, PUSH_SUBSYSTEM_UP } from './constants'; import { IPlatform } from '../../sdkFactory/types'; -import { WARN_8, INFO_11, INFO_13, INFO_14, ERROR_10, INFO_15, INFO_12 } from '../../logger/constants'; +import { STREAMING_FALLBACK, STREAMING_REFRESH_TOKEN, STREAMING_CONNECTING, STREAMING_DISABLED, ERROR_STREAMING_AUTH, STREAMING_DISCONNECTING, STREAMING_RECONNECT } from '../../logger/constants'; /** * PushManager factory: @@ -40,7 +40,7 @@ export default function pushManagerFactory( try { sseClient = new SSEClient(settings.urls.streaming, platform.getEventSource); } catch (e) { - log.warn(WARN_8, [e]); + log.warn(STREAMING_FALLBACK, [e]); return; } const authenticate = authenticateFactory(fetchAuth); @@ -88,14 +88,14 @@ export default function pushManagerFactory( // Set token refresh 10 minutes before expirationTime const delayInSeconds = expirationTime - issuedAt - SECONDS_BEFORE_EXPIRATION; - log.info(INFO_11, [delayInSeconds]); + log.info(STREAMING_REFRESH_TOKEN, [delayInSeconds]); timeoutId = setTimeout(connectPush, delayInSeconds * 1000); } function connectPush() { disconnected = false; - log.info(INFO_13); + log.info(STREAMING_CONNECTING); const userKeys = userKey ? Object.keys(workers) : undefined; authenticate(userKeys).then( @@ -105,7 +105,7 @@ export default function pushManagerFactory( // 'pushEnabled: false' is handled as a PUSH_NONRETRYABLE_ERROR instead of PUSH_SUBSYSTEM_DOWN, in order to // close the sseClient in case the org has been bloqued while the instance was connected to streaming if (!authData.pushEnabled) { - log.info(INFO_14); + log.info(STREAMING_DISABLED); pushEmitter.emit(PUSH_NONRETRYABLE_ERROR); return; } @@ -122,7 +122,7 @@ export default function pushManagerFactory( function (error) { if (disconnected) return; - log.error(ERROR_10, [error.message]); + log.error(ERROR_STREAMING_AUTH, [error.message]); // Handle 4XX HTTP errors: 401 (invalid API Key) or 400 (using incorrect API Key, i.e., client-side API Key on server-side) if (error.statusCode >= 400 && error.statusCode < 500) { @@ -139,7 +139,7 @@ export default function pushManagerFactory( // close SSE connection and cancel scheduled tasks function disconnectPush() { disconnected = true; - log.info(INFO_15); + log.info(STREAMING_DISCONNECTING); sseClient.close(); if (timeoutId) clearTimeout(timeoutId); @@ -177,7 +177,7 @@ export default function pushManagerFactory( // retry streaming reconnect with backoff algorithm let delayInMillis = connectPushRetryBackoff.scheduleCall(); - log.info(INFO_12, [delayInMillis / 1000]); + log.info(STREAMING_RECONNECT, [delayInMillis / 1000]); pushEmitter.emit(PUSH_SUBSYSTEM_DOWN); // no harm if polling already }); diff --git a/src/sync/streaming/pushManagerCS.ts b/src/sync/streaming/pushManagerCS.ts index 9a23a9ab..5611eaa0 100644 --- a/src/sync/streaming/pushManagerCS.ts +++ b/src/sync/streaming/pushManagerCS.ts @@ -17,7 +17,7 @@ import { IFetchAuth } from '../../services/types'; import { ISettings } from '../../types'; import { getMatching } from '../../utils/key'; import { IPlatform } from '../../sdkFactory/types'; -import { WARN_8, INFO_11, INFO_13, INFO_14, ERROR_10, INFO_15, INFO_12 } from '../../logger/constants'; +import { STREAMING_FALLBACK, STREAMING_REFRESH_TOKEN, STREAMING_CONNECTING, STREAMING_DISABLED, ERROR_STREAMING_AUTH, STREAMING_DISCONNECTING, STREAMING_RECONNECT } from '../../logger/constants'; /** * PushManager factory for client-side, with support for multiple clients. @@ -38,7 +38,7 @@ export default function pushManagerCSFactory( try { sseClient = new SSEClient(settings.urls.streaming, platform.getEventSource); } catch (e) { - log.warn(WARN_8, [e]); + log.warn(STREAMING_FALLBACK, [e]); return; } const authenticate = authenticateFactory(fetchAuth); @@ -84,14 +84,14 @@ export default function pushManagerCSFactory( // Set token refresh 10 minutes before expirationTime const delayInSeconds = expirationTime - issuedAt - SECONDS_BEFORE_EXPIRATION; - log.info(INFO_11, [delayInSeconds]); + log.info(STREAMING_REFRESH_TOKEN, [delayInSeconds]); timeoutId = setTimeout(connectPush, delayInSeconds * 1000); } function connectPush() { disconnected = false; - log.info(INFO_13); + log.info(STREAMING_CONNECTING); const userKeys = Object.keys(workers); // [Only for client-side] authenticate(userKeys).then( @@ -101,7 +101,7 @@ export default function pushManagerCSFactory( // 'pushEnabled: false' is handled as a PUSH_NONRETRYABLE_ERROR instead of PUSH_SUBSYSTEM_DOWN, in order to // close the sseClient in case the org has been bloqued while the instance was connected to streaming if (!authData.pushEnabled) { - log.info(INFO_14); + log.info(STREAMING_DISABLED); pushEmitter.emit(PUSH_NONRETRYABLE_ERROR); return; } @@ -118,7 +118,7 @@ export default function pushManagerCSFactory( function (error) { if (disconnected) return; - log.error(ERROR_10, [error.message]); + log.error(ERROR_STREAMING_AUTH, [error.message]); // Handle 4XX HTTP errors: 401 (invalid API Key) or 400 (using incorrect API Key, i.e., client-side API Key on server-side) if (error.statusCode >= 400 && error.statusCode < 500) { @@ -135,7 +135,7 @@ export default function pushManagerCSFactory( // close SSE connection and cancel scheduled tasks function disconnectPush() { disconnected = true; - log.info(INFO_15); + log.info(STREAMING_DISCONNECTING); sseClient.close(); if (timeoutId) clearTimeout(timeoutId); @@ -172,7 +172,7 @@ export default function pushManagerCSFactory( // retry streaming reconnect with backoff algorithm let delayInMillis = connectPushRetryBackoff.scheduleCall(); - log.info(INFO_12, [delayInMillis / 1000]); + log.info(STREAMING_RECONNECT, [delayInMillis / 1000]); pushEmitter.emit(PUSH_SUBSYSTEM_DOWN); // no harm if polling already }); diff --git a/src/sync/streaming/pushManagerSS.ts b/src/sync/streaming/pushManagerSS.ts index 138a52e9..37de7fce 100644 --- a/src/sync/streaming/pushManagerSS.ts +++ b/src/sync/streaming/pushManagerSS.ts @@ -14,7 +14,7 @@ import { authenticateFactory } from './AuthClient'; import SSEClient from './SSEClient'; import { ISettings } from '../../types'; import { IPlatform } from '../../sdkFactory/types'; -import { WARN_8, INFO_11, INFO_13, INFO_14, ERROR_10, INFO_15, INFO_12 } from '../../logger/constants'; +import { STREAMING_FALLBACK, STREAMING_REFRESH_TOKEN, STREAMING_CONNECTING, STREAMING_DISABLED, ERROR_STREAMING_AUTH, STREAMING_DISCONNECTING, STREAMING_RECONNECT } from '../../logger/constants'; /** * PushManager factory for server-side @@ -34,7 +34,7 @@ export default function pushManagerSSFactory( try { sseClient = new SSEClient(settings.urls.streaming, platform.getEventSource); } catch (e) { - log.warn(WARN_8, [e]); + log.warn(STREAMING_FALLBACK, [e]); return; } const authenticate = authenticateFactory(fetchAuth); @@ -65,14 +65,14 @@ export default function pushManagerSSFactory( // Set token refresh 10 minutes before expirationTime const delayInSeconds = expirationTime - issuedAt - SECONDS_BEFORE_EXPIRATION; - log.info(INFO_11, [delayInSeconds]); + log.info(STREAMING_REFRESH_TOKEN, [delayInSeconds]); timeoutId = setTimeout(connectPush, delayInSeconds * 1000); } function connectPush() { disconnected = false; - log.info(INFO_13); + log.info(STREAMING_CONNECTING); authenticate().then( function (authData) { @@ -81,7 +81,7 @@ export default function pushManagerSSFactory( // 'pushEnabled: false' is handled as a PUSH_NONRETRYABLE_ERROR instead of PUSH_SUBSYSTEM_DOWN, in order to // close the sseClient in case the org has been bloqued while the instance was connected to streaming if (!authData.pushEnabled) { - log.info(INFO_14); + log.info(STREAMING_DISABLED); pushEmitter.emit(PUSH_NONRETRYABLE_ERROR); return; } @@ -95,7 +95,7 @@ export default function pushManagerSSFactory( function (error) { if (disconnected) return; - log.error(ERROR_10, [error.message]); + log.error(ERROR_STREAMING_AUTH, [error.message]); // Handle 4XX HTTP errors: 401 (invalid API Key) or 400 (using incorrect API Key, i.e., client-side API Key on server-side) if (error.statusCode >= 400 && error.statusCode < 500) { @@ -112,7 +112,7 @@ export default function pushManagerSSFactory( // close SSE connection and cancel scheduled tasks function disconnectPush() { disconnected = true; - log.info(INFO_15); + log.info(STREAMING_DISCONNECTING); sseClient.close(); if (timeoutId) clearTimeout(timeoutId); @@ -149,7 +149,7 @@ export default function pushManagerSSFactory( // retry streaming reconnect with backoff algorithm let delayInMillis = connectPushRetryBackoff.scheduleCall(); - log.info(INFO_12, [delayInMillis / 1000]); + log.info(STREAMING_RECONNECT, [delayInMillis / 1000]); pushEmitter.emit(PUSH_SUBSYSTEM_DOWN); // no harm if polling already }); diff --git a/src/sync/submitters/eventsSyncTask.ts b/src/sync/submitters/eventsSyncTask.ts index e7024c0c..3a15a6e0 100644 --- a/src/sync/submitters/eventsSyncTask.ts +++ b/src/sync/submitters/eventsSyncTask.ts @@ -3,7 +3,7 @@ import { IPostEventsBulk } from '../../services/types'; import { ISyncTask, ITimeTracker } from '../types'; import { submitterSyncTaskFactory } from './submitterSyncTask'; import { ILogger } from '../../logger/types'; -import { INFO_16 } from '../../logger/constants'; +import { SUBMITTERS_PUSH_FULL_EVENTS_QUEUE } from '../../logger/constants'; /** * Sync task that periodically posts tracked events @@ -36,7 +36,7 @@ export function eventsSyncTaskFactory( // register eventsSubmitter to be executed when events cache is full eventsCache.setOnFullQueueCb(() => { - log.info(INFO_16); + log.info(SUBMITTERS_PUSH_FULL_EVENTS_QUEUE); syncTask.execute(); }); diff --git a/src/sync/submitters/submitterSyncTask.ts b/src/sync/submitters/submitterSyncTask.ts index da6a9301..cbee1913 100644 --- a/src/sync/submitters/submitterSyncTask.ts +++ b/src/sync/submitters/submitterSyncTask.ts @@ -2,7 +2,7 @@ import syncTaskFactory from '../syncTask'; import { ISyncTask, ITimeTracker } from '../types'; import { IRecorderCacheConsumerSync } from '../../storages/types'; import { ILogger } from '../../logger/types'; -import { INFO_17, WARN_9, WARN_10 } from '../../logger/constants'; +import { SUBMITTERS_PUSH, SUBMITTERS_PUSH_FAILS, SUBMITTERS_PUSH_RETRY } from '../../logger/constants'; /** * Base function to create submitter sync tasks, such as ImpressionsSyncTask and EventsSyncTask @@ -26,7 +26,7 @@ export function submitterSyncTaskFactory( const data = sourceCache.state(); const dataCount: number | '' = typeof data.length === 'number' ? data.length : ''; - log.info(INFO_17, [dataCount, dataName]); + log.info(SUBMITTERS_PUSH, [dataCount, dataName]); const latencyTrackerStop = latencyTracker && latencyTracker.start(); const jsonPayload = JSON.stringify(fromCacheToPayload ? fromCacheToPayload(data) : data); @@ -37,14 +37,14 @@ export function submitterSyncTaskFactory( sourceCache.clear(); // we clear the queue if request successes. }).catch(err => { if (!maxRetries) { - log.warn(WARN_9, [dataCount, dataName, err]); + log.warn(SUBMITTERS_PUSH_FAILS, [dataCount, dataName, err]); } else if (retries === maxRetries) { retries = 0; sourceCache.clear(); // we clear the queue if request fails after retries. - log.warn(WARN_9, [dataCount, dataName, err]); + log.warn(SUBMITTERS_PUSH_FAILS, [dataCount, dataName, err]); } else { retries++; - log.warn(WARN_10, [dataCount, dataName, err]); + log.warn(SUBMITTERS_PUSH_RETRY, [dataCount, dataName, err]); } }); diff --git a/src/sync/syncManagerOnline.ts b/src/sync/syncManagerOnline.ts index 4a0a0099..04a0c98f 100644 --- a/src/sync/syncManagerOnline.ts +++ b/src/sync/syncManagerOnline.ts @@ -8,7 +8,7 @@ import { IStorageSync } from '../storages/types'; import { IPushManagerFactoryParams, IPushManager, IPushManagerCS } from './streaming/types'; import { IPollingManager, IPollingManagerCS, IPollingManagerFactoryParams } from './polling/types'; import { PUSH_SUBSYSTEM_UP, PUSH_SUBSYSTEM_DOWN } from './streaming/constants'; -import { INFO_18, INFO_19, INFO_20 } from '../logger/constants'; +import { SYNC_START_POLLING, SYNC_CONTINUE_POLLING, SYNC_STOP_POLLING } from '../logger/constants'; /** * Online SyncManager factory. @@ -59,15 +59,15 @@ export function syncManagerOnlineFactory( function startPolling() { if (!pollingManager.isRunning()) { - log.info(INFO_18); + log.info(SYNC_START_POLLING); pollingManager.start(); } else { - log.info(INFO_19); + log.info(SYNC_CONTINUE_POLLING); } } function stopPollingAndSyncAll() { - log.info(INFO_20); + log.info(SYNC_STOP_POLLING); // if polling, stop if (pollingManager.isRunning()) pollingManager.stop(); diff --git a/src/sync/syncTask.ts b/src/sync/syncTask.ts index cb63701c..321ea99e 100644 --- a/src/sync/syncTask.ts +++ b/src/sync/syncTask.ts @@ -1,4 +1,4 @@ -import { DEBUG_48, DEBUG_47, DEBUG_49 } from '../logger/constants'; +import { SYNC_TASK_EXECUTE, SYNC_TASK_START, SYNC_TASK_STOP } from '../logger/constants'; import { ILogger } from '../logger/types'; import { ISyncTask } from './types'; @@ -16,7 +16,7 @@ export default function syncTaskFactory(log: ILogge function execute(...args: Input) { executing = true; - log.debug(DEBUG_48, [taskName]); + log.debug(SYNC_TASK_EXECUTE, [taskName]); return task(...args).then(result => { executing = false; if (running) timeoutID = setTimeout(execute, period, ...args); @@ -34,7 +34,7 @@ export default function syncTaskFactory(log: ILogge start(...args: Input) { if (!running) { running = true; - log.debug(DEBUG_47, [taskName, period]); + log.debug(SYNC_TASK_START, [taskName, period]); return execute(...args); } }, @@ -42,7 +42,7 @@ export default function syncTaskFactory(log: ILogge stop() { running = false; if (timeoutID) { - log.debug(DEBUG_49, [taskName]); + log.debug(SYNC_TASK_STOP, [taskName]); clearTimeout(timeoutID); timeoutID = undefined; } diff --git a/src/trackers/eventTracker.ts b/src/trackers/eventTracker.ts index 960924dc..343e737f 100644 --- a/src/trackers/eventTracker.ts +++ b/src/trackers/eventTracker.ts @@ -4,7 +4,7 @@ import { IEventsCacheBase } from '../storages/types'; import { IEventsHandler, IEventTracker } from './types'; import { SplitIO } from '../types'; import { ILogger } from '../logger/types'; -import { INFO_21, WARN_11 } from '../logger/constants'; +import { EVENTS_TRACKER_SUCCESS, ERROR_EVENTS_TRACKER } from '../logger/constants'; /** * Event tracker stores events in cache and pass them to the integrations manager if provided. @@ -24,7 +24,7 @@ export default function eventTrackerFactory( const msg = `event of type "${eventTypeId}" for traffic type "${trafficTypeName}". Key: ${key}. Value: ${value}. Timestamp: ${timestamp}. ${properties ? 'With properties.' : 'With no properties.'}`; if (tracked) { - log.info(INFO_21, [msg]); + log.info(EVENTS_TRACKER_SUCCESS, [msg]); if (integrationsManager) { // Wrap in a timeout because we don't want it to be blocking. setTimeout(function () { @@ -36,7 +36,7 @@ export default function eventTrackerFactory( }, 0); } } else { - log.warn(WARN_11, [msg]); + log.warn(ERROR_EVENTS_TRACKER, [msg]); } return tracked; diff --git a/src/trackers/impressionsTracker.ts b/src/trackers/impressionsTracker.ts index 53ec5178..00e7c25f 100644 --- a/src/trackers/impressionsTracker.ts +++ b/src/trackers/impressionsTracker.ts @@ -7,7 +7,7 @@ import { IMetadata } from '../dtos/types'; import { SplitIO, ImpressionDTO } from '../types'; import { IImpressionObserver } from './impressionObserver/types'; import { ILogger } from '../logger/types'; -import { DEBUG_50, ERROR_11, ERROR_12 } from '../logger/constants'; +import { IMPRESSIONS_TRACKER_SUCCESS, ERROR_IMPRESSIONS_TRACKER, ERROR_IMPRESSIONS_LISTENER } from '../logger/constants'; /** * Impressions tracker stores impressions in cache and pass them to the listener and integrations manager if provided. @@ -63,9 +63,9 @@ export default function impressionsTrackerFactory( // If we're on an async storage, handle error and log it. if (thenable(res)) { res.then(() => { - log.debug(DEBUG_50, [impressionsCount, impressionsCount === 1 ? '' : 's']); + log.debug(IMPRESSIONS_TRACKER_SUCCESS, [impressionsCount, impressionsCount === 1 ? '' : 's']); }).catch(err => { - log.error(ERROR_11, [impressionsCount, impressionsCount === 1 ? '' : 's', err]); + log.error(ERROR_IMPRESSIONS_TRACKER, [impressionsCount, impressionsCount === 1 ? '' : 's', err]); }); } @@ -89,7 +89,7 @@ export default function impressionsTrackerFactory( try { // An exception on the listeners should not break the SDK. if (impressionListener) impressionListener.logImpression(impressionData); } catch (err) { - log.error(ERROR_12, [err]); + log.error(ERROR_IMPRESSIONS_LISTENER, [err]); } }, 0); } diff --git a/src/utils/inputValidation/__tests__/isOperational.spec.ts b/src/utils/inputValidation/__tests__/isOperational.spec.ts index 0d32547a..f78afb51 100644 --- a/src/utils/inputValidation/__tests__/isOperational.spec.ts +++ b/src/utils/inputValidation/__tests__/isOperational.spec.ts @@ -1,4 +1,4 @@ -import { WARN_CLIENT_NOT_READY, ERROR_CLIENT_DESTROYED } from '../../../logger/constants'; +import { CLIENT_NOT_READY, ERROR_CLIENT_DESTROYED } from '../../../logger/constants'; import { loggerMock } from '../../../logger/__tests__/sdkLogger.mock'; import { validateIfNotDestroyed, validateIfOperational } from '../isOperational'; @@ -58,7 +58,7 @@ describe('validateIfOperational', () => { expect(validateIfOperational(loggerMock, readinessManagerMock, 'test_method')).toBe(false); // It should return true if SDK was ready. expect(readinessManagerMock.isReady).toBeCalledTimes(1); // It checks for SDK_READY status. expect(readinessManagerMock.isReadyFromCache).toBeCalledTimes(1); // It checks for SDK_READY_FROM_CACHE status. - expect(loggerMock.warn).toBeCalledWith(WARN_CLIENT_NOT_READY, ['test_method']); // It should log the expected warning. + expect(loggerMock.warn).toBeCalledWith(CLIENT_NOT_READY, ['test_method']); // It should log the expected warning. expect(loggerMock.error).not.toBeCalled(); // But it should not log any errors. }); }); diff --git a/src/utils/inputValidation/apiKey.ts b/src/utils/inputValidation/apiKey.ts index a629815a..0b891abf 100644 --- a/src/utils/inputValidation/apiKey.ts +++ b/src/utils/inputValidation/apiKey.ts @@ -1,4 +1,4 @@ -import { ERROR_NULL, ERROR_EMPTY, ERROR_INVALID, WARN_API_KEY, INSTANTIATION_LB } from '../../logger/constants'; +import { ERROR_NULL, ERROR_EMPTY, ERROR_INVALID, WARN_API_KEY, logPrefixInstantiation } from '../../logger/constants'; import { ILogger } from '../../logger/types'; import { isString } from '../lang'; @@ -8,14 +8,14 @@ const item = 'api_key'; export function validateApiKey(log: ILogger, maybeApiKey: any): string | false { let apiKey: string | false = false; if (maybeApiKey == undefined) { // eslint-disable-line eqeqeq - log.error(ERROR_NULL, [INSTANTIATION_LB, item]); + log.error(ERROR_NULL, [logPrefixInstantiation, item]); } else if (isString(maybeApiKey)) { if (maybeApiKey.length > 0) apiKey = maybeApiKey; else - log.error(ERROR_EMPTY, [INSTANTIATION_LB, item]); + log.error(ERROR_EMPTY, [logPrefixInstantiation, item]); } else { - log.error(ERROR_INVALID, [INSTANTIATION_LB, item]); + log.error(ERROR_INVALID, [logPrefixInstantiation, item]); } return apiKey; diff --git a/src/utils/inputValidation/isOperational.ts b/src/utils/inputValidation/isOperational.ts index 666b9d33..05ad0aad 100644 --- a/src/utils/inputValidation/isOperational.ts +++ b/src/utils/inputValidation/isOperational.ts @@ -1,4 +1,4 @@ -import { ERROR_CLIENT_DESTROYED, WARN_CLIENT_NOT_READY } from '../../logger/constants'; +import { ERROR_CLIENT_DESTROYED, CLIENT_NOT_READY } from '../../logger/constants'; import { ILogger } from '../../logger/types'; import { IReadinessManager } from '../../readiness/types'; @@ -12,6 +12,6 @@ export function validateIfNotDestroyed(log: ILogger, readinessManager: IReadines export function validateIfOperational(log: ILogger, readinessManager: IReadinessManager, method: string) { if (readinessManager.isReady() || readinessManager.isReadyFromCache()) return true; - log.warn(WARN_CLIENT_NOT_READY, [method]); + log.warn(CLIENT_NOT_READY, [method]); return false; } diff --git a/src/utils/settingsValidation/__tests__/splitFilters.spec.ts b/src/utils/settingsValidation/__tests__/splitFilters.spec.ts index 6024ec2e..3aa994dd 100644 --- a/src/utils/settingsValidation/__tests__/splitFilters.spec.ts +++ b/src/utils/settingsValidation/__tests__/splitFilters.spec.ts @@ -7,7 +7,7 @@ import { splitFilters, queryStrings, groupedFilters } from '../../../__tests__/m // Test target import { validateSplitFilters } from '../splitFilters'; -import { DEBUG_SPLITS_FILTER, ERROR_INVALID, ERROR_EMPTY_ARRAY, WARN_SPLITS_FILTER_IGNORED, WARN_SPLITS_FILTER_INVALID, WARN_SPLITS_FILTER_EMPTY } from '../../../logger/constants'; +import { SETTINGS_SPLITS_FILTER, ERROR_INVALID, ERROR_EMPTY_ARRAY, WARN_SPLITS_FILTER_IGNORED, WARN_SPLITS_FILTER_INVALID, WARN_SPLITS_FILTER_EMPTY } from '../../../logger/constants'; describe('validateSplitFilters', () => { @@ -48,7 +48,7 @@ describe('validateSplitFilters', () => { groupedFilters: { byName: [], byPrefix: [] } }; expect(validateSplitFilters(loggerMock, splitFilters, STANDALONE_MODE)).toEqual(output); // filters without values - expect(loggerMock.debug).toBeCalledWith(DEBUG_SPLITS_FILTER, [null]); + expect(loggerMock.debug).toBeCalledWith(SETTINGS_SPLITS_FILTER, [null]); loggerMock.debug.mockClear(); splitFilters.push( @@ -58,7 +58,7 @@ describe('validateSplitFilters', () => { { type: 'byName', values: [13] }); output.validFilters.push({ type: 'byName', values: [13] }); expect(validateSplitFilters(loggerMock, splitFilters, STANDALONE_MODE)).toEqual(output); // some filters are invalid - expect(loggerMock.debug.mock.calls).toEqual([[DEBUG_SPLITS_FILTER, [null]]]); + expect(loggerMock.debug.mock.calls).toEqual([[SETTINGS_SPLITS_FILTER, [null]]]); expect(loggerMock.warn.mock.calls).toEqual([ [WARN_SPLITS_FILTER_INVALID, [3]], // invalid value of `type` property [WARN_SPLITS_FILTER_INVALID, [4]], // invalid type of `values` property @@ -82,7 +82,7 @@ describe('validateSplitFilters', () => { groupedFilters: groupedFilters[i] }; expect(validateSplitFilters(loggerMock, splitFilters[i], STANDALONE_MODE)).toEqual(output); // splitFilters #${i} - expect(loggerMock.debug).lastCalledWith(DEBUG_SPLITS_FILTER, [queryStrings[i]]); + expect(loggerMock.debug).lastCalledWith(SETTINGS_SPLITS_FILTER, [queryStrings[i]]); } else { // tests where validateSplitFilters throws an exception expect(() => validateSplitFilters(loggerMock, splitFilters[i], STANDALONE_MODE)).toThrow(queryStrings[i]); diff --git a/src/utils/settingsValidation/logger/pluggableLogger.ts b/src/utils/settingsValidation/logger/pluggableLogger.ts index 90746543..7b149990 100644 --- a/src/utils/settingsValidation/logger/pluggableLogger.ts +++ b/src/utils/settingsValidation/logger/pluggableLogger.ts @@ -28,7 +28,7 @@ export function validateLogger(settings: { debug: unknown }): ILogger { const log = new Logger({ logLevel: logLevel || initialLogLevel }); - // @ts-ignore // if logLevel is undefined at this point, it means that `debug` value is invalid + // @ts-ignore // `debug` value is invalid if logLevel is undefined at this point if (!logLevel) log._log(LogLevels.ERROR, 'Invalid `debug` value at config. Logs will be disabled.'); return log; diff --git a/src/utils/settingsValidation/splitFilters.ts b/src/utils/settingsValidation/splitFilters.ts index 8542a44b..7c474952 100644 --- a/src/utils/settingsValidation/splitFilters.ts +++ b/src/utils/settingsValidation/splitFilters.ts @@ -3,7 +3,7 @@ import { validateSplits } from '../inputValidation/splits'; import { ISplitFiltersValidation } from '../../dtos/types'; import { SplitIO } from '../../types'; import { ILogger } from '../../logger/types'; -import { WARN_SPLITS_FILTER_IGNORED, WARN_SPLITS_FILTER_EMPTY, WARN_SPLITS_FILTER_INVALID, DEBUG_SPLITS_FILTER, SETTINGS_LB } from '../../logger/constants'; +import { WARN_SPLITS_FILTER_IGNORED, WARN_SPLITS_FILTER_EMPTY, WARN_SPLITS_FILTER_INVALID, SETTINGS_SPLITS_FILTER, logPrefixSettings } from '../../logger/constants'; // Split filters metadata. // Ordered according to their precedency when forming the filter query string: `&names=&prefixes=` @@ -39,7 +39,7 @@ function validateFilterType(maybeFilterType: any): maybeFilterType is SplitIO.Sp */ function validateSplitFilter(log: ILogger, type: SplitIO.SplitFilterType, values: string[], maxLength: number) { // validate and remove invalid and duplicated values - let result = validateSplits(log, values, SETTINGS_LB, `${type} filter`, `${type} filter value`); + let result = validateSplits(log, values, logPrefixSettings, `${type} filter`, `${type} filter value`); if (result) { // check max length @@ -125,7 +125,7 @@ export function validateSplitFilters(log: ILogger, maybeSplitFilters: any, mode: // build query string res.queryString = queryStringBuilder(res.groupedFilters); - log.debug(DEBUG_SPLITS_FILTER, [res.queryString]); + log.debug(SETTINGS_SPLITS_FILTER, [res.queryString]); return res; }