refactor

Author: raju-opti

lib/common_exports.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-export { LogLevel, LogHandler, getLogger, setLogHandler } from './modules/logging';
+// export { LogLevel, LogHandler, getLogger, setLogHandler } from './modules/logging';
 export { LOG_LEVEL } from './utils/enums';
 export { createLogger } from './plugins/logger';
 export { createStaticProjectConfigManager } from './project_config/config_manager_factory';

lib/modules/logging/index.ts renamed to lib/error/error_handler.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright 2019, Optimizely
+ * Copyright 2019, 2025, Optimizely
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -13,6 +13,14 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export * from './errorHandler'
-export * from './models'
-export * from './logger'
+/**
+ * @export
+ * @interface ErrorHandler
+ */
+export interface ErrorHandler {
+  /**
+   * @param {Error} exception
+   * @memberof ErrorHandler
+   */
+  handleError(exception: Error): void
+}

lib/error/error_notifier.ts

@@ -0,0 +1,37 @@
+import { sprintf } from "../utils/fns";
+import { ErrorHandler } from "./error_handler";
+import { OptimizelyError } from "./optimizly_error";
+
+export interface ErrorNotifier {
+  notify(error: OptimizelyError): void;
+  child(name: string): ErrorNotifier;
+}
+
+export interface ErrorMessageResolver {
+  resolve(baseMessage: string): string;
+}
+
+export class DefaultErrorNotifier implements ErrorNotifier {
+  private name: string;
+  private errorHandler: ErrorHandler;
+  private messageResolver: ErrorMessageResolver;
+
+  constructor(errorHandler: ErrorHandler, messageResolver: ErrorMessageResolver, name?: string) {
+    this.errorHandler = errorHandler;
+    this.messageResolver = messageResolver;
+    this.name = name || '';
+  }
+
+  notify(error: OptimizelyError): void {
+    const ErrorMessage = error.getErrorMessage();
+    const resolvedBase = this.messageResolver.resolve(ErrorMessage.baseMessage);
+    const messagePrefix = this.name ? `${this.name}: ` : '';
+    const message = `${messagePrefix}${sprintf(resolvedBase, ...ErrorMessage.params)}`;
+    error.setMessage(message);
+    this.errorHandler.handleError(error);
+  }
+
+  child(name: string): ErrorNotifier {
+    return new DefaultErrorNotifier(this.errorHandler, this.messageResolver, name);
+  }
+}

lib/error/error_reporter.ts

@@ -0,0 +1,42 @@
+import { LoggerFacade } from "../logging/logger";
+import { ErrorNotifier } from "./error_notifier";
+import { OptimizelyError } from "./optimizly_error";
+
+export class ErrorReporter {
+  private logger?: LoggerFacade;
+  private errorNotifier?: ErrorNotifier;
+
+  constructor(logger?: LoggerFacade, errorNotifier?: ErrorNotifier) {
+    this.logger = logger;
+    this.errorNotifier = errorNotifier;
+  }
+
+  report(error: OptimizelyError): void;
+  report(baseMessage: string, ...params: any[]): void;
+
+  report(error: OptimizelyError | string, ...params: any[]): void {
+    if (typeof error === 'string') {
+      error = new OptimizelyError(error, ...params);
+      this.report(error);
+      return;
+    }
+
+    const errorMessage = error.getErrorMessage();
+
+    if (this.errorNotifier) {
+      this.errorNotifier.notify(error);
+    }
+
+    if (this.logger) {
+      this.logger.error(errorMessage.baseMessage, ...errorMessage.params);
+    }
+  }
+
+  setLogger(logger: LoggerFacade): void {
+    this.logger = logger;
+  }
+
+  setErrorNotifier(errorNotifier: ErrorNotifier): void {
+    this.errorNotifier = errorNotifier;
+  }
+}

lib/error/optimizly_error.ts

@@ -0,0 +1,26 @@
+type ErrorMessage = {
+  baseMessage: string;
+  params: any[];
+};
+
+export class OptimizelyError extends Error {
+  private baseMessage: string;
+  private params: any[];
+  constructor(baseMessage: string, ...params: any[]) {
+    super();
+    this.name = 'OptimizelyError';
+    this.baseMessage = baseMessage;
+    this.params = params;
+  }
+
+  getErrorMessage(): ErrorMessage {
+    return {
+      baseMessage: this.baseMessage,
+      params: this.params,
+    };
+  }
+
+  setMessage(message: string): void {
+    this.message = message;
+  }
+}

lib/error_messages.ts

@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+export const NOTIFICATION_LISTENER_EXCEPTION = 'Notification listener for (%s) threw exception: %s';
 export const BROWSER_ODP_MANAGER_INITIALIZATION_FAILED = '%s: Error initializing Browser ODP Manager.';
 export const CONDITION_EVALUATOR_ERROR = '%s: Error evaluating audience condition of type %s: %s';
 export const DATAFILE_AND_SDK_KEY_MISSING =

lib/index.node.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import { getLogger, setErrorHandler, getErrorHandler, LogLevel, setLogHandler, setLogLevel } from './modules/logging';
+// import { getLogger, setErrorHandler, getErrorHandler, LogLevel, setLogHandler, setLogLevel } from './modules/logging';
 import Optimizely from './optimizely';
 import * as enums from './utils/enums';
 import * as loggerPlugin from './plugins/logger';
@@ -30,9 +30,6 @@ import { createVuidManager } from './vuid/vuid_manager_factory.node';
 import { createOdpManager } from './odp/odp_manager_factory.node';
 import { ODP_DISABLED } from './log_messages';
 
-const logger = getLogger();
-setLogLevel(LogLevel.ERROR);
-
 const DEFAULT_EVENT_BATCH_SIZE = 10;
 const DEFAULT_EVENT_FLUSH_INTERVAL = 30000; // Unit is ms, default is 30s
 const DEFAULT_EVENT_MAX_QUEUE_SIZE = 10000;
@@ -45,54 +42,20 @@ const DEFAULT_EVENT_MAX_QUEUE_SIZE = 10000;
  */
 const createInstance = function(config: Config): Client | null {
   try {
-    let hasLogger = false;
-    let isValidInstance = false;
-
-    // TODO warn about setting per instance errorHandler / logger / logLevel
-    if (config.errorHandler) {
-      setErrorHandler(config.errorHandler);
-    }
-    if (config.logger) {
-      // only set a logger in node if one is provided, by not setting we are noop-ing
-      hasLogger = true;
-      setLogHandler(config.logger);
-      // respect the logger's shouldLog functionality
-      setLogLevel(LogLevel.NOTSET);
-    }
-    if (config.logLevel !== undefined) {
-      setLogLevel(config.logLevel);
-    }
-    try {
-      configValidator.validate(config);
-      isValidInstance = true;
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    } catch (ex) {
-      if (hasLogger) {
-        logger.error(ex);
-      } else {
-        console.error(ex.message);
-      }
-    }
-
-    const errorHandler = getErrorHandler();
-    const notificationCenter = createNotificationCenter({ logger: logger, errorHandler: errorHandler });
+    configValidator.validate(config);
 
     const { clientEngine, clientVersion } = config;
 
     const optimizelyOptions = {
       ...config,
       clientEngine: clientEngine || enums.NODE_CLIENT_ENGINE,
       clientVersion: clientVersion || enums.CLIENT_VERSION,
-      logger,
-      errorHandler,
-      notificationCenter,
-      isValidInstance,
     };
 
     return new Optimizely(optimizelyOptions);
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
   } catch (e) {
-    logger.error(e);
+    // logger.error(e);
     return null;
   }
 };
@@ -105,8 +68,6 @@ export {
   defaultErrorHandler as errorHandler,
   defaultEventDispatcher as eventDispatcher,
   enums,
-  setLogHandler as setLogger,
-  setLogLevel,
   createInstance,
   OptimizelyDecideOption,
   createPollingProjectConfigManager,
@@ -124,8 +85,6 @@ export default {
   errorHandler: defaultErrorHandler,
   eventDispatcher: defaultEventDispatcher,
   enums,
-  setLogger: setLogHandler,
-  setLogLevel,
   createInstance,
   OptimizelyDecideOption,
   createPollingProjectConfigManager,

lib/log_messages.ts

@@ -30,7 +30,6 @@ export const INVALID_OBJECT = '%s: Optimizely object is not valid. Failing %s.';
 export const INVALID_CLIENT_ENGINE = '%s: Invalid client engine passed: %s. Defaulting to node-sdk.';
 export const INVALID_DEFAULT_DECIDE_OPTIONS = '%s: Provided default decide options is not an array.';
 export const INVALID_DECIDE_OPTIONS = '%s: Provided decide options is not an array. Using default decide options.';
-export const NOTIFICATION_LISTENER_EXCEPTION = '%s: Notification listener for (%s) threw exception: %s';
 export const NO_ROLLOUT_EXISTS = '%s: There is no rollout of feature %s.';
 export const NOT_ACTIVATING_USER = '%s: Not activating user %s for experiment %s.';
 export const NOT_TRACKING_USER = '% s: Not tracking user %s.';

lib/modules/logging/logger.spec.ts renamed to lib/logging/logger.spec.ts

@@ -0,0 +1,140 @@
+/**
+ * Copyright 2019, 2024, Optimizely
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { sprintf } from '../utils/fns'
+
+export enum LogLevel {
+  Debug,
+  Info,
+  Warn,
+  Error,
+}
+
+export interface LoggerFacade {
+  log(logLevel: LogLevel, message: string | Error, ...splat: any[]): void;
+  info(message: string | Error, ...splat: any[]): void;
+  debug(message: string | Error, ...splat: any[]): void;
+  warn(message: string | Error, ...splat: any[]): void;
+  error(message: string | Error, ...splat: any[]): void;
+  child(name: string): LoggerFacade;
+}
+
+export interface LogHandler {
+  log(level: LogLevel, message: string, ...splat: any[]): void
+}
+
+export class ConsoleLogHandler implements LogHandler {
+  private prefix: string
+
+  constructor(prefix?: string) {
+    this.prefix = prefix || '[OPTIMIZELY]'
+  }
+
+  log(level: LogLevel, message: string) : void {
+    const log = `${this.prefix} - ${level} ${this.getTime()} ${message}`
+    this.consoleLog(level, log)
+  }
+
+  private getTime(): string {
+    return new Date().toISOString()
+  }
+
+  private consoleLog(logLevel: LogLevel, log: string) : void {
+    const methodName = LogLevel[logLevel].toLowerCase()
+    const method: any = console[methodName as keyof Console] || console.log;
+    method.bind(console)(log);
+  }
+}
+
+export interface LogResolver {
+  log(msg: string): string;
+  err(msg: string): string;
+}
+
+type OptimizelyLoggerConfig = {
+  logHandler: LogHandler,
+  logResolver?: LogResolver,
+  level: LogLevel,
+  name?: string,
+};
+
+export class OptimizelyLogger implements LoggerFacade {
+  private name?: string;
+  private prefix: string;
+  private logHandler: LogHandler;
+  private logResolver?: LogResolver;
+  private level: LogLevel;
+
+  constructor(config: OptimizelyLoggerConfig) {
+    this.logHandler = config.logHandler;
+    this.logResolver = config.logResolver;
+    this.level = config.level;
+    this.name = config.name;
+    this.prefix = this.name ? `${this.name}: ` : '';
+  }
+
+  child(name: string): OptimizelyLogger {
+    return new OptimizelyLogger({
+      logHandler: this.logHandler,
+      logResolver: this.logResolver,
+      level: this.level,
+      name: `${this.name}.${name}`,
+    });
+  }
+
+  info(message: string | Error, ...splat: any[]): void {
+    this.log(LogLevel.Info, message, ...splat)
+  }
+
+  debug(message: string | Error, ...splat: any[]): void {
+    this.log(LogLevel.Debug, message, ...splat)
+  }
+
+  warn(message: string | Error, ...splat: any[]): void {
+    this.log(LogLevel.Warn, message, ...splat)
+  }
+
+  error(message: string | Error, ...splat: any[]): void {
+    this.log(LogLevel.Error, message, ...splat)
+  }
+
+  private handleLog(level: LogLevel, message: string, ...splat: any[]) {
+    const log = `${this.prefix}${sprintf(message, splat)}`
+    this.logHandler.log(level, log);
+  }
+
+  log(level: LogLevel, message: string | Error, ...splat: any[]): void {
+    if (level < this.level) {
+      return;
+    }
+
+    if (message instanceof Error) {
+      this.handleLog(level, message.toString());
+      return;
+    }
+
+    if (!this.logResolver) {
+      this.handleLog(level, message, ...splat);
+      return;
+    }
+
+    const resolvedMessage = level < LogLevel.Warn ? this.logResolver.log(message)
+      : this.logResolver.err(message);
+    
+    if (resolvedMessage) {
+      this.handleLog(level, resolvedMessage, ...splat);
+    }
+  }
+}