up

raju-opti · raju-opti · commit cf87023c7ad0 · 2025-01-06T22:16:18.000+06:00
diff --git a/lib/core/audience_evaluator/index.ts b/lib/core/audience_evaluator/index.ts
@@ -13,9 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { getLogger } from '../../modules/logging';
-
-import fns from '../../utils/fns';
+;
 import {
   LOG_LEVEL,
 } from '../../utils/enums';
@@ -25,11 +23,13 @@ import * as odpSegmentsConditionEvaluator from './odp_segment_condition_evaluato
 import { Audience, Condition, OptimizelyUserContext } from '../../shared_types';
 import { CONDITION_EVALUATOR_ERROR, UNKNOWN_CONDITION_TYPE } from '../../error_messages';
 import { AUDIENCE_EVALUATION_RESULT, EVALUATING_AUDIENCE} from '../../log_messages';
+import { LoggerFacade } from '../../logging/logger';
 
-const logger = getLogger();
 const MODULE_NAME = 'AUDIENCE_EVALUATOR';
 
 export class AudienceEvaluator {
+  private logger?: LoggerFacade;
+
   private typeToEvaluatorMap: {
     [key: string]: {
       [key: string]: (condition: Condition, user: OptimizelyUserContext) => boolean | null
@@ -43,7 +43,8 @@ export class AudienceEvaluator {
    *                                                   Optimizely evaluators cannot be overridden.
    * @constructor
    */
-  constructor(UNSTABLE_conditionEvaluators: unknown) {
+  constructor(UNSTABLE_conditionEvaluators: unknown, logger?: LoggerFacade) {
+    this.logger = logger;
     this.typeToEvaluatorMap = {
       ...UNSTABLE_conditionEvaluators as any,
       custom_attribute: customAttributeConditionEvaluator,
@@ -77,16 +78,15 @@ export class AudienceEvaluator {
     const evaluateAudience = (audienceId: string) => {
       const audience = audiencesById[audienceId];
       if (audience) {
-        logger.log(
-          LOG_LEVEL.DEBUG,
-          EVALUATING_AUDIENCE, MODULE_NAME, audienceId, JSON.stringify(audience.conditions)
+        this.logger?.debug(
+          EVALUATING_AUDIENCE, audienceId, JSON.stringify(audience.conditions)
         );
         const result = conditionTreeEvaluator.evaluate(
           audience.conditions as unknown[] ,
           this.evaluateConditionWithUserAttributes.bind(this, user)
         );
         const resultText = result === null ? 'UNKNOWN' : result.toString().toUpperCase();
-        logger.log(LOG_LEVEL.DEBUG, AUDIENCE_EVALUATION_RESULT, MODULE_NAME, audienceId, resultText);
+        this.logger?.debug(AUDIENCE_EVALUATION_RESULT, audienceId, resultText);
         return result;
       }
       return null;
@@ -105,15 +105,14 @@ export class AudienceEvaluator {
   evaluateConditionWithUserAttributes(user: OptimizelyUserContext, condition: Condition): boolean | null {
     const evaluator = this.typeToEvaluatorMap[condition.type];
     if (!evaluator) {
-      logger.log(LOG_LEVEL.WARNING, UNKNOWN_CONDITION_TYPE, MODULE_NAME, JSON.stringify(condition));
+      this.logger?.warn(UNKNOWN_CONDITION_TYPE, JSON.stringify(condition));
       return null;
     }
     try {
       return evaluator.evaluate(condition, user);
     } catch (err: any) {
-      logger.log(
-        LOG_LEVEL.ERROR,
-        CONDITION_EVALUATOR_ERROR, MODULE_NAME, condition.type, err.message
+      this.logger?.error(
+        CONDITION_EVALUATOR_ERROR, condition.type, err.message
       );
     }
 
@@ -123,6 +122,6 @@ export class AudienceEvaluator {
 
 export default AudienceEvaluator;
 
-export const createAudienceEvaluator = function(UNSTABLE_conditionEvaluators: unknown): AudienceEvaluator {
-  return new AudienceEvaluator(UNSTABLE_conditionEvaluators);
+export const createAudienceEvaluator = function(UNSTABLE_conditionEvaluators: unknown, logger?: LoggerFacade): AudienceEvaluator {
+  return new AudienceEvaluator(UNSTABLE_conditionEvaluators, logger);
 };
diff --git a/lib/core/decision_service/index.ts b/lib/core/decision_service/index.ts
@@ -142,9 +142,9 @@ export class DecisionService {
   private userProfileService: UserProfileService | null;
 
   constructor(options: DecisionServiceOptions) {
-    this.audienceEvaluator = createAudienceEvaluator(options.UNSTABLE_conditionEvaluators);
-    this.forcedVariationMap = {};
     this.logger = options.logger;
+    this.audienceEvaluator = createAudienceEvaluator(options.UNSTABLE_conditionEvaluators, this.logger);
+    this.forcedVariationMap = {};
     this.userProfileService = options.userProfileService || null;
   }
 
diff --git a/lib/error_messages.ts b/lib/error_messages.ts
@@ -15,7 +15,7 @@
  */
 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 CONDITION_EVALUATOR_ERROR = 'Error evaluating audience condition of type %s: %s';
 export const DATAFILE_AND_SDK_KEY_MISSING =
   '%s: You must provide at least one of sdkKey or datafile. Cannot start Optimizely';
 export const EXPERIMENT_KEY_NOT_IN_DATAFILE = '%s: Experiment key %s is not in datafile.';
@@ -103,7 +103,7 @@ export const EVENT_ACTION_INVALID = 'Event action invalid.';
 export const FAILED_TO_SEND_ODP_EVENTS = 'failed to send odp events';
 export const UNABLE_TO_GET_VUID_VUID_MANAGER_NOT_AVAILABLE = 'Unable to get VUID - VuidManager is not available'
 export const UNKNOWN_CONDITION_TYPE =
-  '%s: Audience condition %s has an unknown condition type. You may need to upgrade to a newer release of the Optimizely SDK.';
+   'Audience condition %s has an unknown condition type. You may need to upgrade to a newer release of the Optimizely SDK.';
 export const UNKNOWN_MATCH_TYPE =
   '%s: Audience condition %s uses an unknown match type. You may need to upgrade to a newer release of the Optimizely SDK.';
 export const UNRECOGNIZED_DECIDE_OPTION = 'Unrecognized decide option %s provided.';
diff --git a/lib/event_processor/batch_event_processor.spec.ts b/lib/event_processor/batch_event_processor.spec.ts
@@ -26,7 +26,7 @@ import { getMockLogger } from '../tests/mock/mock_logger';
 import { getMockRepeater } from '../tests/mock/mock_repeater';
 import * as retry from '../utils/executor/backoff_retry_runner';
 import { ServiceState, StartupLog } from '../service';
-import { LogLevel } from '../modules/logging';
+import { LogLevel } from '../logging/logger';
 
 const getMockDispatcher = () => {
   return {
@@ -53,12 +53,12 @@ describe('QueueingEventProcessor', async () => {
     it('should log startupLogs on start', () => {
       const startupLogs: StartupLog[] = [
         {
-          level: LogLevel.WARNING,
+          level: LogLevel.Warn,
           message: 'warn message',
           params: [1, 2]
         },
         {
-          level: LogLevel.ERROR,
+          level: LogLevel.Error,
           message: 'error message',
           params: [3, 4]
         },
@@ -78,8 +78,8 @@ describe('QueueingEventProcessor', async () => {
 
     
       expect(logger.log).toHaveBeenCalledTimes(2);
-      expect(logger.log).toHaveBeenNthCalledWith(1, LogLevel.WARNING, 'warn message', 1, 2);
-      expect(logger.log).toHaveBeenNthCalledWith(2, LogLevel.ERROR, 'error message', 3, 4);
+      expect(logger.log).toHaveBeenNthCalledWith(1, LogLevel.Warn, 'warn message', 1, 2);
+      expect(logger.log).toHaveBeenNthCalledWith(2, LogLevel.Error, 'error message', 3, 4);
     });
     
     it('should resolve onRunning() when start() is called', async () => { 
diff --git a/lib/event_processor/batch_event_processor.ts b/lib/event_processor/batch_event_processor.ts
@@ -19,7 +19,7 @@ import { Cache } from "../utils/cache/cache";
 import { EventDispatcher, EventDispatcherResponse, LogEvent } from "./event_dispatcher/event_dispatcher";
 import { buildLogEvent } from "./event_builder/log_event";
 import { BackoffController, ExponentialBackoff, IntervalRepeater, Repeater } from "../utils/repeater/repeater";
-import { LoggerFacade } from "../modules/logging";
+import { LoggerFacade } from '../logging/logger';
 import { BaseService, ServiceState, StartupLog } from "../service";
 import { Consumer, Fn, Producer } from "../utils/type";
 import { RunResult, runWithRetry } from "../utils/executor/backoff_retry_runner";
diff --git a/lib/event_processor/event_processor.ts b/lib/event_processor/event_processor.ts
@@ -15,7 +15,6 @@
  */
 import { ConversionEvent, ImpressionEvent } from './event_builder/user_event'
 import { LogEvent } from './event_dispatcher/event_dispatcher'
-import { getLogger } from '../modules/logging'
 import { Service } from '../service'
 import { Consumer, Fn } from '../utils/type';
 
diff --git a/lib/event_processor/event_processor_factory.spec.ts b/lib/event_processor/event_processor_factory.spec.ts
@@ -19,7 +19,7 @@ import { DEFAULT_EVENT_BATCH_SIZE, DEFAULT_EVENT_FLUSH_INTERVAL, DEFAULT_MAX_BAC
 import { BatchEventProcessor, BatchEventProcessorConfig, EventWithId } from './batch_event_processor';
 import { ExponentialBackoff, IntervalRepeater } from '../utils/repeater/repeater';
 import { getMockSyncCache } from '../tests/mock/mock_cache';
-import { LogLevel } from '../modules/logging';
+import { LogLevel } from '../logging/logger';
 
 vi.mock('./batch_event_processor');
 vi.mock('../utils/repeater/repeater');
@@ -160,7 +160,7 @@ describe('getBatchEventProcessor', () => {
 
     const startupLogs = MockBatchEventProcessor.mock.calls[0][0].startupLogs;
     expect(startupLogs).toEqual(expect.arrayContaining([{
-      level: LogLevel.WARNING,
+      level: LogLevel.Warn,
       message: 'Invalid flushInterval %s, defaulting to %s',
       params: [undefined, DEFAULT_EVENT_FLUSH_INTERVAL],
     }]));
@@ -181,7 +181,7 @@ describe('getBatchEventProcessor', () => {
 
     const startupLogs = MockBatchEventProcessor.mock.calls[0][0].startupLogs;
     expect(startupLogs).toEqual(expect.arrayContaining([{
-      level: LogLevel.WARNING,
+      level: LogLevel.Warn,
       message: 'Invalid flushInterval %s, defaulting to %s',
       params: [-1, DEFAULT_EVENT_FLUSH_INTERVAL],
     }]));
@@ -217,7 +217,7 @@ describe('getBatchEventProcessor', () => {
 
     const startupLogs = MockBatchEventProcessor.mock.calls[0][0].startupLogs;
     expect(startupLogs).toEqual(expect.arrayContaining([{
-      level: LogLevel.WARNING,
+      level: LogLevel.Warn,
       message: 'Invalid batchSize %s, defaulting to %s',
       params: [undefined, DEFAULT_EVENT_BATCH_SIZE],
     }]));
@@ -236,7 +236,7 @@ describe('getBatchEventProcessor', () => {
 
     const startupLogs = MockBatchEventProcessor.mock.calls[0][0].startupLogs;
     expect(startupLogs).toEqual(expect.arrayContaining([{
-      level: LogLevel.WARNING,
+      level: LogLevel.Warn,
       message: 'Invalid batchSize %s, defaulting to %s',
       params: [-1, DEFAULT_EVENT_BATCH_SIZE],
     }]));
diff --git a/lib/log_messages.ts b/lib/log_messages.ts
@@ -90,7 +90,7 @@ export const VALID_USER_PROFILE_SERVICE = 'Valid user profile service provided.'
 export const VARIATION_REMOVED_FOR_USER = 'Variation mapped to experiment %s has been removed for user %s.';
 
 export const VALID_BUCKETING_ID = 'BucketingId is valid: "%s"';
-export const EVALUATING_AUDIENCE = '%s: Starting to evaluate audience "%s" with conditions: %s.';
+export const EVALUATING_AUDIENCE = 'Starting to evaluate audience "%s" with conditions: %s.';
 export const EVALUATING_AUDIENCES_COMBINED = 'Evaluating audiences for %s "%s": %s.';
 export const AUDIENCE_EVALUATION_RESULT = '%s: Audience "%s" evaluated to %s.';
 export const AUDIENCE_EVALUATION_RESULT_COMBINED = 'Audiences for %s %s collectively evaluated to %s.';
diff --git a/lib/logging/logger_factory.ts b/lib/logging/logger_factory.ts
@@ -1,20 +1,20 @@
-import { LogLevel, LogResolver } from './logger';
+// import { LogLevel, LogResolver } from './logger';
 
-type LevelPreset = {
-  level: LogLevel;
-  resolver?: LogResolver;
-}
+// type LevelPreset = {
+//   level: LogLevel;
+//   resolver?: LogResolver;
+// }
 
-const levelPresetSymbol = Symbol('levelPreset');
+// const levelPresetSymbol = Symbol('levelPreset');
 
-export type OpaqueLevelPreset = {
-  [levelPresetSymbol]: unknown;
-};
+// export type OpaqueLevelPreset = {
+//   [levelPresetSymbol]: unknown;
+// };
 
-const Info: LevelPreset = {
-  level: LogLevel.Info,
-};
+// const Info: LevelPreset = {
+//   level: LogLevel.Info,
+// };
 
-export const InfoLog: OpaqueLevelPreset = {
-  [levelPresetSymbol]: Info,
-};
+// export const InfoLog: OpaqueLevelPreset = {
+//   [levelPresetSymbol]: Info,
+// };
diff --git a/lib/odp/odp_manager.ts b/lib/odp/odp_manager.ts
@@ -15,7 +15,7 @@
  */
 
 import { v4 as uuidV4} from 'uuid';
-import { LoggerFacade } from '../modules/logging';
+import { LoggerFacade } from '../logging/logger';
 
 import { OdpIntegrationConfig, odpIntegrationsAreEqual } from './odp_config';
 import { OdpEventManager } from './event_manager/odp_event_manager';
diff --git a/lib/odp/segment_manager/odp_segment_api_manager.ts b/lib/odp/segment_manager/odp_segment_api_manager.ts
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import { LoggerFacade, LogLevel } from '../../modules/logging';
+import { LoggerFacade } from '../../logging/logger';
 import { validate } from '../../utils/json_schema_validator';
 import { OdpResponseSchema } from './odp_response_schema';
 import { ODP_USER_KEY } from '../constant';
diff --git a/lib/odp/segment_manager/odp_segment_manager.ts b/lib/odp/segment_manager/odp_segment_manager.ts
@@ -19,7 +19,7 @@ import { OdpSegmentApiManager } from './odp_segment_api_manager';
 import { OdpIntegrationConfig } from '../odp_config';
 import { OptimizelySegmentOption } from './optimizely_segment_option';
 import { ODP_USER_KEY } from '../constant';
-import { LoggerFacade } from '../../modules/logging';
+import { LoggerFacade } from '../../logging/logger';
 import { ODP_CONFIG_NOT_AVAILABLE, ODP_NOT_INTEGRATED } from '../../error_messages';
 
 export interface OdpSegmentManager {
diff --git a/lib/project_config/datafile_manager.ts b/lib/project_config/datafile_manager.ts
@@ -18,7 +18,7 @@ import { Cache } from '../utils/cache/cache';
 import { RequestHandler } from '../utils/http_request_handler/http';
 import { Fn, Consumer } from '../utils/type';
 import { Repeater } from '../utils/repeater/repeater';
-import { LoggerFacade } from '../modules/logging';
+import { LoggerFacade } from '../logging/logger';
 
 export interface DatafileManager extends Service {
   get(): string | undefined;
diff --git a/lib/project_config/optimizely_config.ts b/lib/project_config/optimizely_config.ts
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { LoggerFacade, getLogger } from '../modules/logging';
+import { LoggerFacade } from '../logging/logger'
 import { ProjectConfig } from '../project_config/project_config';
 import { DEFAULT_OPERATOR_TYPES } from '../core/condition_tree_evaluator';
 import {
diff --git a/lib/project_config/project_config_manager.ts b/lib/project_config/project_config_manager.ts
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { LoggerFacade } from '../modules/logging';
+import { LoggerFacade } from '../logging/logger';
 import { createOptimizelyConfig } from './optimizely_config';
 import {  OptimizelyConfig } from '../shared_types';
 import { DatafileManager } from './datafile_manager';
diff --git a/lib/service.ts b/lib/service.ts
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import { LoggerFacade, LogLevel } from "./modules/logging";
+import { LoggerFacade, LogLevel } from './logging/logger'
 import { resolvablePromise, ResolvablePromise } from "./utils/promise/resolvablePromise";
 
 
@@ -76,9 +76,15 @@ export abstract class BaseService implements Service {
   }
 
   protected printStartupLogs(): void {
-    this.startupLogs.forEach(({ level, message, params }) => {
-      this.logger?.log(level, message, ...params);
-    });
+    if (!this.logger) {
+      return;
+    }
+
+    for (const { level, message, params } of this.startupLogs) {
+      const methodName = LogLevel[level].toLowerCase();
+      const method = this.logger[methodName as keyof LoggerFacade];
+      method.call(this.logger, message, ...params);
+    }
   }
 
   onRunning(): Promise<void> {
diff --git a/lib/utils/http_request_handler/request_handler.node.ts b/lib/utils/http_request_handler/request_handler.node.ts
@@ -18,7 +18,7 @@ import https from 'https';
 import url from 'url';
 import { AbortableRequest, Headers, RequestHandler, Response } from './http';
 import decompressResponse from 'decompress-response';
-import { LogHandler } from '../../modules/logging';
+import { LoggerFacade } from '../../logging/logger';
 import { REQUEST_TIMEOUT_MS } from '../enums';
 import { sprintf } from '../fns';
 import { NO_STATUS_CODE_IN_RESPONSE, REQUEST_ERROR, REQUEST_TIMEOUT, UNSUPPORTED_PROTOCOL } from '../../exception_messages';
@@ -27,10 +27,10 @@ import { NO_STATUS_CODE_IN_RESPONSE, REQUEST_ERROR, REQUEST_TIMEOUT, UNSUPPORTED
  * Handles sending requests and receiving responses over HTTP via NodeJS http module
  */
 export class NodeRequestHandler implements RequestHandler {
-  private readonly logger?: LogHandler;
+  private readonly logger?: LoggerFacade;
   private readonly timeout: number;
 
-  constructor(opt: { logger?: LogHandler; timeout?: number } = {}) {
+  constructor(opt: { logger?: LoggerFacade; timeout?: number } = {}) {
     this.logger = opt.logger;
     this.timeout = opt.timeout ?? REQUEST_TIMEOUT_MS;
   }
