Refactor logging service

Author: furkansenharputlu

code_samples/logging.js

@@ -17,6 +17,7 @@
 var winston = require('winston');
 var Config = require('hazelcast-client').Config;
 var HazelcastClient = require('hazelcast-client').Client;
+var LogLevel = require('hazelcast-client').LogLevel;
 
 if (process.argv.length != 3) {
     console.log('Run as node logging.js [logger]');
@@ -40,8 +41,28 @@ if (process.argv.length != 3) {
                 'silly'
             ],
 
-            log: function (level, className, message, furtherInfo) {
-                this.logger.log(this.levels[level], className + ' ' + message);
+            log: function (level, objectName, message, furtherInfo) {
+                this.logger.log(this.levels[level], objectName + ': ' + message, furtherInfo);
+            },
+
+            error: function (objectName, message, furtherInfo) {
+                this.log(LogLevel.ERROR, objectName, message, furtherInfo);
+            },
+
+            debug: function (objectName, message, furtherInfo) {
+                this.log(LogLevel.DEBUG, objectName, message, furtherInfo);
+            },
+
+            warn: function (objectName, message, furtherInfo) {
+                this.log(LogLevel.WARN, objectName, message, furtherInfo);
+            },
+
+            info: function (objectName, message, furtherInfo) {
+                this.log(LogLevel.INFO, objectName, message, furtherInfo);
+            },
+
+            trace: function (objectName, message, furtherInfo) {
+                this.log(LogLevel.TRACE, objectName, message, furtherInfo);
             }
         };
         cfg.properties['hazelcast.logging'] = winstonAdapter;

src/HazelcastClient.ts

@@ -91,8 +91,8 @@ export default class HazelcastClient {
             this.instanceName = 'hz.client_' + this.id;
         }
 
-        LoggingService.initialize(this.config.properties['hazelcast.logging'] as string);
-        this.loggingService = LoggingService.getLoggingService();
+        this.loggingService = new LoggingService(this.config.properties['hazelcast.logging'],
+            this.config.properties['hazelcast.logging.level'] as number);
         this.invocationService = new InvocationService(this);
         this.listenerService = new ListenerService(this);
         this.serializationService = new SerializationServiceV1(this.config.serializationConfig);
@@ -398,10 +398,10 @@ export default class HazelcastClient {
             this.proxyManager.init();
             this.listenerService.start();
             this.statistics.start();
-            this.loggingService.info('HazelcastClient', 'Client started');
+            this.loggingService.getLogger().info('HazelcastClient', 'Client started');
             return this;
         }).catch((e) => {
-            this.loggingService.error('HazelcastClient', 'Client failed to start', e);
+            this.loggingService.getLogger().error('HazelcastClient', 'Client failed to start', e);
             throw e;
         });
     }
@@ -412,7 +412,7 @@ export default class HazelcastClient {
             const urlEndpoint = HazelcastCloudDiscovery.createUrlEndpoint(this.getConfig().properties,
                 cloudConfig.discoveryToken);
             return new HazelcastCloudAddressTranslator(urlEndpoint, this.getConnectionTimeoutMillis(),
-                this.loggingService);
+                this.loggingService.getLogger());
         }
         return new DefaultAddressTranslator();
 
@@ -436,7 +436,8 @@ export default class HazelcastClient {
         if (cloudConfig.enabled) {
             const discoveryToken = cloudConfig.discoveryToken;
             const urlEndpoint = HazelcastCloudDiscovery.createUrlEndpoint(this.getConfig().properties, discoveryToken);
-            return new HazelcastCloudAddressProvider(urlEndpoint, this.getConnectionTimeoutMillis(), this.loggingService);
+            return new HazelcastCloudAddressProvider(urlEndpoint, this.getConnectionTimeoutMillis(),
+                this.loggingService.getLogger());
         }
         return null;
     }

src/HeartbeatService.ts

@@ -18,7 +18,7 @@ import {ClientPingCodec} from './codec/ClientPingCodec';
 import {ConnectionHeartbeatListener} from './core/ConnectionHeartbeatListener';
 import HazelcastClient from './HazelcastClient';
 import {ClientConnection} from './invocation/ClientConnection';
-import {LoggingService} from './logging/LoggingService';
+import {ILogger} from './logging/ILogger';
 
 const PROPERTY_HEARTBEAT_INTERVAL: string = 'hazelcast.client.heartbeat.interval';
 const PROPERTY_HEARTBEAT_TIMEOUT: string = 'hazelcast.client.heartbeat.timeout';
@@ -31,14 +31,15 @@ export class Heartbeat {
     private heartbeatTimeout: number;
     private heartbeatInterval: number;
     private listeners: ConnectionHeartbeatListener[] = [];
-    private logger = LoggingService.getLoggingService();
+    private logger: ILogger;
 
     // Actually it is a NodeJS.Timer. Another typing file that comes with a module we use causes TSD to see
     // return type of setTimeout as number. Because of this we defined timer property as `any` type.
     private timer: any;
 
     constructor(client: HazelcastClient) {
         this.client = client;
+        this.logger = this.client.getLoggingService().getLogger();
         this.heartbeatInterval = this.client.getConfig().properties[PROPERTY_HEARTBEAT_INTERVAL] as number;
         this.heartbeatTimeout = this.client.getConfig().properties[PROPERTY_HEARTBEAT_TIMEOUT] as number;
     }

src/ListenerService.ts

@@ -26,14 +26,14 @@ import {ClientEventRegistration} from './invocation/ClientEventRegistration';
 import {Invocation} from './invocation/InvocationService';
 import {RegistrationKey} from './invocation/RegistrationKey';
 import {ListenerMessageCodec} from './ListenerMessageCodec';
-import {LoggingService} from './logging/LoggingService';
 import {copyObjectShallow, DeferredPromise} from './Util';
 import {UuidUtil} from './util/UuidUtil';
+import {ILogger} from './logging/ILogger';
 
 export class ListenerService implements ConnectionHeartbeatListener {
     private client: HazelcastClient;
     private internalEventEmitter: EventEmitter;
-    private logger = LoggingService.getLoggingService();
+    private logger: ILogger;
     private isShutdown: boolean;
     private isSmartService: boolean;
 
@@ -46,6 +46,7 @@ export class ListenerService implements ConnectionHeartbeatListener {
     constructor(client: HazelcastClient) {
         this.isShutdown = false;
         this.client = client;
+        this.logger = this.client.getLoggingService().getLogger();
         this.isSmartService = this.client.getConfig().networkConfig.smartRouting;
         this.internalEventEmitter = new EventEmitter();
         this.internalEventEmitter.setMaxListeners(0);

src/PartitionService.ts

@@ -16,7 +16,7 @@
 
 import * as Promise from 'bluebird';
 import HazelcastClient from './HazelcastClient';
-import {LoggingService} from './logging/LoggingService';
+import {ILogger} from './logging/ILogger';
 import Address = require('./Address');
 import ClientMessage = require('./ClientMessage');
 import GetPartitionsCodec = require('./codec/GetPartitionsCodec');
@@ -30,10 +30,11 @@ export class PartitionService {
     private partitionCount: number;
     private partitionRefreshTask: any;
     private isShutdown: boolean;
-    private logger = LoggingService.getLoggingService();
+    private logger: ILogger;
 
     constructor(client: HazelcastClient) {
         this.client = client;
+        this.logger = client.getLoggingService().getLogger();
         this.isShutdown = false;
     }
 

src/aggregation/AggregatorFactory.ts

@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-import {LoggingService} from '../logging/LoggingService';
 import {IdentifiedDataSerializable, IdentifiedDataSerializableFactory} from '../serialization/Serializable';
 import {
     Aggregator,
@@ -31,6 +30,7 @@ import {
     MinAggregator,
     NumberAverageAggregator,
 } from './Aggregator';
+import {ILogger} from '../logging/ILogger';
 
 export class AggregatorFactory implements IdentifiedDataSerializableFactory {
 
@@ -56,7 +56,7 @@ export class AggregatorFactory implements IdentifiedDataSerializableFactory {
     static readonly MAX_BY = 17; // needs object to implement Java's Comparable interface
     static readonly MIN_BY = 18; // needs object to implement Java's Comparable interface
 
-    private logger = LoggingService.getLoggingService();
+    private logger: ILogger;
     private idToConstructor: { [id: number]: Aggregator<any> } = {};
 
     constructor() {

src/config/Config.ts

@@ -28,6 +28,7 @@ import {Properties} from './Properties';
 import {ReliableTopicConfig} from './ReliableTopicConfig';
 import {SerializationConfig} from './SerializationConfig';
 import {Statistics} from '../statistics/Statistics';
+import {LogLevel} from '..';
 
 /**
  * Top level configuration object of Hazelcast client. Other configurations items are properties of this object.
@@ -45,6 +46,8 @@ export class ClientConfig {
         'hazelcast.invalidation.reconciliation.interval.seconds': 60,
         'hazelcast.invalidation.max.tolerated.miss.count': 10,
         'hazelcast.invalidation.min.reconciliation.interval.seconds': 30,
+        'hazelcast.logging': 'default',
+        'hazelcast.logging.level': LogLevel.INFO,
     };
 
     /**

src/config/JsonConfigLocator.ts

@@ -17,17 +17,18 @@
 import * as Promise from 'bluebird';
 import * as fs from 'fs';
 import * as Path from 'path';
-import {LoggingService} from '../logging/LoggingService';
+import {LoggingService, LogLevel} from '../logging/LoggingService';
 import {ConfigBuilder} from './ConfigBuilder';
 import {DeferredPromise} from '../Util';
+import {DefaultLogger} from '../logging/DefaultLogger';
 
 export class JsonConfigLocator {
     static readonly ENV_VARIABLE_NAME = 'HAZELCAST_CLIENT_CONFIG';
     static readonly DEFAULT_FILE_NAME = 'hazelcast-client.json';
 
     private buffer: Buffer;
     private configLocation: string;
-    private logger = LoggingService.getLoggingService();
+    private logger = new DefaultLogger(LogLevel.INFO);
 
     load(): Promise<void> {
         return this.loadFromEnvironment().then((loaded: boolean) => {

src/config/Properties.ts

@@ -14,8 +14,10 @@
  * limitations under the License.
  */
 
-import {ILogger} from '../logging/LoggingService';
+import {ILogger} from '../logging/ILogger';
 
 export interface Properties {
     [prop: string]: string | number | boolean | ILogger;
 }
+
+export type Property = string | number | boolean | ILogger;

src/discovery/HazelcastCloudAddressProvider.ts

@@ -14,25 +14,25 @@
  * limitations under the License.
  */
 
-import {LoggingService} from '../logging/LoggingService';
 import {HazelcastCloudDiscovery} from './HazelcastCloudDiscovery';
 import {AddressProvider} from '../connection/AddressProvider';
 import * as Promise from 'bluebird';
+import {ILogger} from '../logging/ILogger';
 
 export class HazelcastCloudAddressProvider implements AddressProvider {
-    private readonly loggingService: LoggingService;
+    private readonly logger: ILogger;
     private readonly cloudDiscovery: HazelcastCloudDiscovery;
 
-    constructor(endpointUrl: string, connectionTimeoutMillis: number, loggingService: LoggingService) {
+    constructor(endpointUrl: string, connectionTimeoutMillis: number, logger: ILogger) {
         this.cloudDiscovery = new HazelcastCloudDiscovery(endpointUrl, connectionTimeoutMillis);
-        this.loggingService = loggingService;
+        this.logger = logger;
     }
 
     loadAddresses(): Promise<string[]> {
         return this.cloudDiscovery.discoverNodes().then((res) => {
             return Array.from(res.keys());
         }).catch((e) => {
-            this.loggingService.warn('HazelcastCloudAddressProvider',
+            this.logger.warn('HazelcastCloudAddressProvider',
                 'Failed to load addresses from hazelcast.cloud : ' + e.message);
             return [];
         });