Make OFF a log level

furkansenharputlu · mustafaiman · commit d2b447e20f97 · 2018-12-12T10:46:44.000-05:00
diff --git a/code_samples/logging.js b/code_samples/logging.js
@@ -21,7 +21,7 @@ var LogLevel = require('hazelcast-client').LogLevel;
 
 if (process.argv.length != 3) {
     console.log('Run as node logging.js [logger]');
-    console.log('[logger]: winston/default/off');
+    console.log('[logger]: winston/default');
 } else {
     var cfg = new Config.ClientConfig();
 
diff --git a/src/HazelcastClient.ts b/src/HazelcastClient.ts
@@ -91,11 +91,11 @@ export default class HazelcastClient {
             this.instanceName = 'hz.client_' + this.id;
         }
 
-        this.loggingService = new LoggingService(this.config.properties['hazelcast.logging'],
+        this.loggingService = new LoggingService(this.config.customLogger,
             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);
+        this.serializationService = new SerializationServiceV1(this, this.config.serializationConfig);
         this.proxyManager = new ProxyManager(this);
         this.nearCacheManager = new NearCacheManager(this);
         this.partitionService = new PartitionService(this);
diff --git a/src/aggregation/AggregatorFactory.ts b/src/aggregation/AggregatorFactory.ts
@@ -59,7 +59,8 @@ export class AggregatorFactory implements IdentifiedDataSerializableFactory {
     private logger: ILogger;
     private idToConstructor: { [id: number]: Aggregator<any> } = {};
 
-    constructor() {
+    constructor(logger: ILogger) {
+        this.logger = logger;
         this.idToConstructor[AggregatorFactory.COUNT] = CountAggregator;
         this.idToConstructor[AggregatorFactory.DOUBLE_AVG] = DoubleAverageAggregator;
         this.idToConstructor[AggregatorFactory.DOUBLE_SUM] = DoubleSumAggregator;
diff --git a/src/config/Config.ts b/src/config/Config.ts
@@ -29,6 +29,7 @@ import {ReliableTopicConfig} from './ReliableTopicConfig';
 import {SerializationConfig} from './SerializationConfig';
 import {Statistics} from '../statistics/Statistics';
 import {LogLevel} from '..';
+import {ILogger} from '../logging/ILogger';
 
 /**
  * Top level configuration object of Hazelcast client. Other configurations items are properties of this object.
@@ -46,7 +47,6 @@ 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,
     };
 
@@ -56,6 +56,7 @@ export class ClientConfig {
     instanceName: string;
     groupConfig: GroupConfig = new GroupConfig();
     networkConfig: ClientNetworkConfig = new ClientNetworkConfig();
+    customLogger: ILogger;
     customCredentials: any = null;
     listeners: ListenerConfig = new ListenerConfig();
     listenerConfigs: ImportConfig[] = [];
diff --git a/src/config/Properties.ts b/src/config/Properties.ts
@@ -17,7 +17,7 @@
 import {ILogger} from '../logging/ILogger';
 
 export interface Properties {
-    [prop: string]: string | number | boolean | ILogger;
+    [prop: string]: Property;
 }
 
 export type Property = string | number | boolean | ILogger;
diff --git a/src/logging/ILogger.ts b/src/logging/ILogger.ts
@@ -23,50 +23,50 @@ export interface ILogger {
 
     /**
      * Logs a message with an associated objectName and furtherInfo at the given level.
-     * @param {LogLevel} the log level
-     * @param {string} the object in which the message is logged
-     * @param {string} the message to log
-     * @param further info about the log
+     * @param level the log level
+     * @param objectName name of the object in which the message is logged
+     * @param message the message to log
+     * @param furtherInfo further info about the log
      */
     log(level: LogLevel, objectName: string, message: string, furtherInfo: any): void;
 
     /**
      * Logs a message with an associated objectName and furtherInfo at the error level.
-     * @param {string} the object in which the message is logged
-     * @param {string} the message to log
-     * @param further info about the log
+     * @param objectName name of the object in which the message is logged
+     * @param message the message to log
+     * @param furtherInfo further info about the log
      */
     error(objectName: string, message: string, furtherInfo?: any): void;
 
     /**
      * Logs a message with an associated objectName and furtherInfo at the warn level.
-     * @param {string} the object in which the message is logged
-     * @param {string} the message to log
-     * @param further info about the log
+     * @param objectName name of the object in which the message is logged
+     * @param message the message to log
+     * @param furtherInfo further info about the log
      */
     warn(objectName: string, message: string, furtherInfo?: any): void;
 
     /**
      * Logs a message with an associated objectName and furtherInfo at the info level.
-     * @param {string} the object in which the message is logged
-     * @param {string} the message to log
-     * @param further info about the log
+     * @param objectName name of the object in which the message is logged
+     * @param message the message to log
+     * @param furtherInfo further info about the log
      */
     info(objectName: string, message: string, furtherInfo?: any): void;
 
     /**
      * Logs a message with an associated objectName and furtherInfo at the debug level.
-     * @param {string} the object in which the message is logged
-     * @param {string} the message to log
-     * @param further info about the log
+     * @param objectName name of the object in which the message is logged
+     * @param message the message to log
+     * @param furtherInfo further info about the log
      */
     debug(objectName: string, message: string, furtherInfo?: any): void;
 
     /**
      * Logs a message with an associated objectName and furtherInfo at the trace level.
-     * @param {string} the object in which the message is logged
-     * @param {string} the message to log
-     * @param further info about the log
+     * @param objectName name of the object in which the message is logged
+     * @param message the message to log
+     * @param furtherInfo further info about the log
      */
     trace(objectName: string, message: string, furtherInfo?: any): void;
 }
diff --git a/src/logging/LoggingService.ts b/src/logging/LoggingService.ts
@@ -14,12 +14,12 @@
  * limitations under the License.
  */
 
-import {NoLogger} from './NoLogger';
 import {Property} from '../config/Properties';
 import {DefaultLogger} from './DefaultLogger';
 import {ILogger} from './ILogger';
 
 export enum LogLevel {
+    OFF = -1,
     ERROR = 0,
     WARN = 1,
     INFO = 2,
@@ -31,20 +31,20 @@ export class LoggingService {
 
     private readonly logger: ILogger;
 
-    constructor(loggingProperty: Property, logLevel: number) {
-        if (loggingProperty === 'off') {
-            this.logger = new NoLogger();
-        } else if (loggingProperty === 'default') {
+    constructor(customLogger: ILogger, logLevel: number) {
+        if (customLogger == null) {
             this.logger = new DefaultLogger(logLevel);
-        } else if (this.isLogger(loggingProperty)) {
-            this.logger = loggingProperty;
+        } else if (this.isLogger(customLogger)) {
+            this.logger = customLogger;
         } else {
-            throw new RangeError('Logging type unknown: ' + loggingProperty);
+            throw new RangeError('Logger should implement ILogger functions!');
         }
     }
 
     isLogger(loggingProperty: Property): loggingProperty is ILogger {
-        return (loggingProperty as ILogger).log !== undefined;
+        loggingProperty = (loggingProperty as ILogger);
+        return loggingProperty.log !== undefined && loggingProperty.error !== undefined && loggingProperty.warn !== undefined &&
+            loggingProperty.info !== undefined && loggingProperty.debug !== undefined && loggingProperty.trace !== undefined;
     }
 
     getLogger(): ILogger {
diff --git a/src/logging/NoLogger.ts b/src/logging/NoLogger.ts
diff --git a/src/nearcache/MetadataFetcher.ts b/src/nearcache/MetadataFetcher.ts
@@ -22,8 +22,8 @@ import HazelcastClient from '../HazelcastClient';
 import {Invocation} from '../invocation/InvocationService';
 import {PartitionService} from '../PartitionService';
 import {RepairingHandler} from './RepairingHandler';
-import ClientMessage = require('../ClientMessage');
 import {ILogger} from '../logging/ILogger';
+import ClientMessage = require('../ClientMessage');
 
 export class MetadataFetcher {
 
@@ -32,6 +32,7 @@ export class MetadataFetcher {
     private logger: ILogger;
 
     constructor(client: HazelcastClient) {
+        this.logger = client.getLoggingService().getLogger();
         this.client = client;
         this.partitionService = this.client.getPartitionService();
     }
diff --git a/src/proxy/BaseProxy.ts b/src/proxy/BaseProxy.ts
@@ -26,7 +26,7 @@ import ClientMessage = require('../ClientMessage');
  */
 export class BaseProxy {
 
-    public client: HazelcastClient;
+    protected client: HazelcastClient;
     protected name: string;
     protected serviceName: string;
 
diff --git a/src/proxy/topic/ReliableTopicListenerRunner.ts b/src/proxy/topic/ReliableTopicListenerRunner.ts
@@ -37,14 +37,14 @@ export class ReliableTopicListenerRunner<E> {
     private listenerId: string;
 
     constructor(listenerId: string, listener: MessageListener<E>, ringbuffer: Ringbuffer<ReliableTopicMessage>,
-                batchSize: number, serializationService: SerializationService, proxy: ReliableTopicProxy<E>) {
+                batchSize: number, serializationService: SerializationService, logger: ILogger, proxy: ReliableTopicProxy<E>) {
         this.listenerId = listenerId;
         this.listener = listener;
         this.ringbuffer = ringbuffer;
         this.batchSize = batchSize;
         this.serializationService = serializationService;
         this.proxy = proxy;
-        this.logger = this.proxy.client.getLoggingService().getLogger();
+        this.logger = logger;
     }
 
     public next(): void {
diff --git a/src/proxy/topic/ReliableTopicProxy.ts b/src/proxy/topic/ReliableTopicProxy.ts
@@ -62,7 +62,7 @@ export class ReliableTopicProxy<E> extends BaseProxy implements ITopic<E> {
         const listenerId = UuidUtil.generate().toString();
 
         const runner = new ReliableTopicListenerRunner(listenerId, listener, this.ringbuffer,
-            this.batchSize, this.serializationService, this);
+            this.batchSize, this.serializationService, this.client.getLoggingService().getLogger(), this);
 
         this.runners[listenerId] = runner;
 
diff --git a/src/serialization/SerializationService.ts b/src/serialization/SerializationService.ts
@@ -52,6 +52,7 @@ import {ObjectDataInput, PositionalObjectDataOutput} from './ObjectData';
 import {PortableSerializer} from './portable/PortableSerializer';
 import {PREDICATE_FACTORY_ID, PredicateFactory} from './PredicateFactory';
 import {IdentifiedDataSerializableFactory} from './Serializable';
+import HazelcastClient from '../HazelcastClient';
 
 export interface SerializationService {
     toData(object: any, paritioningStrategy?: any): Data;
@@ -77,8 +78,10 @@ export class SerializationServiceV1 implements SerializationService {
     private serializerNameToId: { [name: string]: number };
     private numberType: string;
     private serializationConfig: SerializationConfig;
+    private client: HazelcastClient;
 
-    constructor(serializationConfig: SerializationConfig) {
+    constructor(client: HazelcastClient, serializationConfig: SerializationConfig) {
+        this.client = client;
         this.serializationConfig = serializationConfig;
         this.registry = {};
         this.serializerNameToId = {};
@@ -276,7 +279,7 @@ export class SerializationServiceV1 implements SerializationService {
         factories[PREDICATE_FACTORY_ID] = new PredicateFactory(DefaultPredicates);
         factories[RELIABLE_TOPIC_MESSAGE_FACTORY_ID] = new ReliableTopicMessageFactory();
         factories[ClusterDataFactoryHelper.FACTORY_ID] = new ClusterDataFactory();
-        factories[AggregatorFactory.FACTORY_ID] = new AggregatorFactory();
+        factories[AggregatorFactory.FACTORY_ID] = new AggregatorFactory(this.client.getLoggingService().getLogger());
         this.registerSerializer('identified', new IdentifiedDataSerializableSerializer(factories));
     }
 
diff --git a/test/LoggingTest.js b/test/LoggingTest.js
@@ -94,7 +94,7 @@ describe('Logging Test', function () {
             loggingHappened = true;
         });
         var cfg = new Config.ClientConfig();
-        cfg.properties['hazelcast.logging'] = winstonAdapter;
+        cfg.customLogger = winstonAdapter;
         return HazelcastClient.newHazelcastClient(cfg).then(function (hz) {
             client = hz;
             return expect(loggingHappened).to.be.true;
@@ -103,7 +103,7 @@ describe('Logging Test', function () {
 
     it('no logging', function () {
         var cfg = new Config.ClientConfig();
-        cfg.properties['hazelcast.logging'] = 'off';
+        cfg.properties['hazelcast.logging.level'] = LogLevel.OFF;
         return HazelcastClient.newHazelcastClient(cfg).then(function (hz) {
             client = hz;
             return sinon.assert.notCalled(console.log);
@@ -119,7 +119,7 @@ describe('Logging Test', function () {
 
     it('default logging in case of default property', function () {
         var cfg = new Config.ClientConfig();
-        cfg.properties['hazelcast.logging'] = 'default';
+        cfg.properties['hazelcast.logging.level'] = LogLevel.INFO;
         return HazelcastClient.newHazelcastClient(cfg).then(function (hz) {
             client = hz;
             return sinon.assert.called(console.log);
@@ -128,7 +128,7 @@ describe('Logging Test', function () {
 
     it('error in case of unknown property value', function () {
         var cfg = new Config.ClientConfig();
-        cfg.properties['hazelcast.logging'] = 'unknw';
+        cfg.customLogger = 'unknw';
         return expect(HazelcastClient.newHazelcastClient.bind(this, cfg)).to.throw(Error);
     });
 
diff --git a/test/discovery/HazelcastCloudProviderTest.js b/test/discovery/HazelcastCloudProviderTest.js
@@ -37,7 +37,7 @@ describe('HazelcastCloudProvider Test', function () {
         expectedAddresses.set('10.0.0.1:5702', new Address('198.51.100.1', 5702));
         expectedAddresses.set('10.0.0.2:5701', new Address('198.51.100.2', 5701));
 
-        var logger = new LoggingService('default', LogLevel.INFO).getLogger();
+        var logger = new LoggingService(null, LogLevel.INFO).getLogger();
         hazelcastCloudDiscovery = new HazelcastCloudDiscovery();
         sinon.stub(HazelcastCloudDiscovery.prototype, 'discoverNodes').callsFake(() => Promise.resolve(expectedAddresses));
 
diff --git a/test/discovery/HazelcastCloudTranslatorTest.js b/test/discovery/HazelcastCloudTranslatorTest.js
@@ -40,7 +40,7 @@ describe('HazelcastCloudTranslator Test', function () {
         lookup.set(privateAddress, publicAddress);
         lookup.set('127.0.0.2:5701', new Address('192.168.0.2', 5701));
 
-        var logger = new LoggingService('default', LogLevel.INFO).getLogger();
+        var logger = new LoggingService(null, LogLevel.INFO).getLogger();
         hazelcastCloudDiscovery = new HazelcastCloudDiscovery();
 
         translator = new HazelcastCloudAddressTranslator(hazelcastCloudDiscovery, null, logger);

Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@`
`17`	`17`	`import {ILogger} from '../logging/ILogger';`
`18`	`18`
`19`	`19`	`export interface Properties {`
`20`		`- [prop: string]: string \| number \| boolean \| ILogger;`
	`20`	`+ [prop: string]: Property;`
`21`	`21`	`}`
`22`	`22`
`23`	`23`	`export type Property = string \| number \| boolean \| ILogger;`