@celerispay/hazelcast-client 3.12.5

package/lib/invocation/InvocationService.js

@@ -0,0 +1,387 @@
+"use strict";
+/*
+ * Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved.
+ *
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+var assert = require("assert");
+var Promise = require("bluebird");
+var BitsUtil_1 = require("../BitsUtil");
+var HazelcastError_1 = require("../HazelcastError");
+var Util_1 = require("../Util");
+var ClientMessage = require("../ClientMessage");
+var EXCEPTION_MESSAGE_TYPE = 109;
+var MAX_FAST_INVOCATION_COUNT = 5;
+var PROPERTY_INVOCATION_RETRY_PAUSE_MILLIS = 'hazelcast.client.invocation.retry.pause.millis';
+var PROPERTY_INVOCATION_TIMEOUT_MILLIS = 'hazelcast.client.invocation.timeout.millis';
+var PROPERTY_CLEAN_RESOURCES_MILLIS = 'hazelcast.client.internal.clean.resources.millis';
+/**
+ * A request to be sent to a hazelcast node.
+ */
+var Invocation = /** @class */ (function () {
+    function Invocation(client, request, timeoutMillis) {
+        this.invokeCount = 0;
+        this.client = client;
+        this.invocationService = client.getInvocationService();
+        this.deadline = timeoutMillis === undefined
+            ? Date.now() + this.invocationService.getInvocationTimeoutMillis()
+            : Date.now() + timeoutMillis;
+        this.request = request;
+    }
+    Invocation.isRetrySafeError = function (err) {
+        return err instanceof HazelcastError_1.IOError
+            || err instanceof HazelcastError_1.HazelcastInstanceNotActiveError
+            || err instanceof HazelcastError_1.RetryableHazelcastError;
+    };
+    Invocation.prototype.shouldRetry = function (err) {
+        if (Invocation.isRetrySafeError(err)) {
+            return true;
+        }
+        if (err instanceof HazelcastError_1.TargetDisconnectedError) {
+            return this.request.isRetryable() || this.invocationService.redoOperationEnabled();
+        }
+        return false;
+    };
+    /**
+     * @returns {boolean}
+     */
+    Invocation.prototype.hasPartitionId = function () {
+        return this.hasOwnProperty('partitionId') && this.partitionId >= 0;
+    };
+    Invocation.prototype.isAllowedToRetryOnSelection = function (err) {
+        return (this.connection == null && this.address == null) || !(err instanceof HazelcastError_1.IOError);
+    };
+    return Invocation;
+}());
+exports.Invocation = Invocation;
+/**
+ * Sends requests to appropriate nodes. Resolves waiting promises with responses.
+ */
+var InvocationService = /** @class */ (function () {
+    function InvocationService(hazelcastClient) {
+        this.correlationCounter = 1;
+        this.eventHandlers = new Map();
+        this.pending = new Map();
+        this.maxRetryAttempts = 10;
+        this.partitionFailureBackoff = 2000; // 2 seconds backoff for partition failures
+        this.client = hazelcastClient;
+        this.logger = this.client.getLoggingService().getLogger();
+        var config = hazelcastClient.getConfig();
+        if (config.networkConfig.smartRouting) {
+            this.doInvoke = this.invokeSmart;
+        }
+        else {
+            this.doInvoke = this.invokeNonSmart;
+        }
+        this.invocationRetryPauseMillis = config.properties[PROPERTY_INVOCATION_RETRY_PAUSE_MILLIS];
+        this.invocationTimeoutMillis = config.properties[PROPERTY_INVOCATION_TIMEOUT_MILLIS];
+        this.cleanResourcesMillis = config.properties[PROPERTY_CLEAN_RESOURCES_MILLIS];
+        this.redoOperation = config.networkConfig.redoOperation;
+        this.isShutdown = false;
+    }
+    InvocationService.prototype.start = function () {
+        this.cleanResourcesTask = this.scheduleCleanResourcesTask(this.cleanResourcesMillis);
+    };
+    InvocationService.prototype.shutdown = function () {
+        var _this = this;
+        if (this.isShutdown) {
+            return;
+        }
+        this.isShutdown = true;
+        if (this.cleanResourcesTask !== undefined) {
+            Util_1.cancelRepetitionTask(this.cleanResourcesTask);
+        }
+        this.pending.forEach(function (invocation) {
+            _this.notifyError(invocation, new HazelcastError_1.ClientNotActiveError('Client is shutting down.'));
+        });
+    };
+    InvocationService.prototype.redoOperationEnabled = function () {
+        return this.redoOperation;
+    };
+    InvocationService.prototype.invoke = function (invocation) {
+        invocation.deferred = Util_1.DeferredPromise();
+        var newCorrelationId = this.correlationCounter++;
+        invocation.request.setCorrelationId(newCorrelationId);
+        this.doInvoke(invocation);
+        return invocation.deferred.promise;
+    };
+    /**
+     * Invokes given invocation on specified connection.
+     * @param connection
+     * @param request
+     * @param handler called with values returned from server for this invocation.
+     * @returns
+     */
+    InvocationService.prototype.invokeOnConnection = function (connection, request, handler) {
+        var invocation = new Invocation(this.client, request);
+        invocation.connection = connection;
+        if (handler) {
+            invocation.handler = handler;
+        }
+        return this.invoke(invocation);
+    };
+    /**
+     * Invokes given invocation on the node that owns given partition.
+     * @param request
+     * @param partitionId
+     * @param timeoutMillis optional override for the invocation timeout
+     * @returns
+     */
+    InvocationService.prototype.invokeOnPartition = function (request, partitionId, timeoutMillis) {
+        var invocation = new Invocation(this.client, request, timeoutMillis);
+        invocation.partitionId = partitionId;
+        return this.invoke(invocation);
+    };
+    /**
+     * Invokes given invocation on the host with given address.
+     * @param request
+     * @param target
+     * @returns
+     */
+    InvocationService.prototype.invokeOnTarget = function (request, target) {
+        var invocation = new Invocation(this.client, request);
+        invocation.address = target;
+        return this.invoke(invocation);
+    };
+    /**
+     * Invokes given invocation on any host.
+     * Useful when an operation is not bound to any host but a generic operation.
+     * @param request
+     * @returns
+     */
+    InvocationService.prototype.invokeOnRandomTarget = function (request) {
+        return this.invoke(new Invocation(this.client, request));
+    };
+    InvocationService.prototype.getInvocationTimeoutMillis = function () {
+        return this.invocationTimeoutMillis;
+    };
+    InvocationService.prototype.getInvocationRetryPauseMillis = function () {
+        return this.invocationRetryPauseMillis;
+    };
+    /**
+     * Removes the handler for all event handlers with a specific correlation id.
+     * @param id correlation id
+     */
+    InvocationService.prototype.removeEventHandler = function (id) {
+        if (this.eventHandlers.hasOwnProperty('' + id)) {
+            this.eventHandlers.delete(id);
+        }
+    };
+    /**
+     * Extract codec specific properties in a protocol message and resolves waiting promise.
+     * @param buffer
+     */
+    InvocationService.prototype.processResponse = function (buffer) {
+        var _this = this;
+        var clientMessage = new ClientMessage(buffer);
+        var correlationId = clientMessage.getCorrelationId();
+        var messageType = clientMessage.getMessageType();
+        if (clientMessage.hasFlags(BitsUtil_1.BitsUtil.LISTENER_FLAG)) {
+            setImmediate(function () {
+                var invocation = _this.eventHandlers.get(correlationId);
+                if (invocation !== undefined) {
+                    invocation.handler(clientMessage);
+                }
+            });
+            return;
+        }
+        var pendingInvocation = this.pending.get(correlationId);
+        if (pendingInvocation === undefined) {
+            if (!this.isShutdown) {
+                this.logger.warn('InvocationService', 'Found no registration for invocation id ' + correlationId);
+            }
+            return;
+        }
+        var deferred = pendingInvocation.deferred;
+        if (messageType === EXCEPTION_MESSAGE_TYPE) {
+            var remoteError = this.client.getErrorFactory().createErrorFromClientMessage(clientMessage);
+            this.notifyError(pendingInvocation, remoteError);
+        }
+        else {
+            this.pending.delete(correlationId);
+            deferred.resolve(clientMessage);
+        }
+    };
+    InvocationService.prototype.scheduleCleanResourcesTask = function (periodMillis) {
+        var _this = this;
+        return Util_1.scheduleWithRepetition(function () {
+            _this.pending.forEach(function (invocation) {
+                var connection = invocation.sendConnection;
+                if (connection === undefined) {
+                    return;
+                }
+                if (!connection.isAlive()) {
+                    _this.notifyError(invocation, new HazelcastError_1.TargetDisconnectedError('Target member disconnected.'));
+                }
+            });
+        }, periodMillis, periodMillis);
+    };
+    InvocationService.prototype.invokeSmart = function (invocation) {
+        var _this = this;
+        var invocationPromise;
+        invocation.invokeCount++;
+        if (invocation.hasOwnProperty('connection')) {
+            invocationPromise = this.send(invocation, invocation.connection);
+        }
+        else if (invocation.hasPartitionId()) {
+            invocationPromise = this.invokeOnPartitionOwner(invocation, invocation.partitionId);
+        }
+        else if (invocation.hasOwnProperty('address')) {
+            invocationPromise = this.invokeOnAddress(invocation, invocation.address);
+        }
+        else {
+            invocationPromise = this.invokeOnOwner(invocation);
+        }
+        invocationPromise.catch(function (err) {
+            _this.notifyError(invocation, err);
+        });
+    };
+    InvocationService.prototype.invokeNonSmart = function (invocation) {
+        var _this = this;
+        var invocationPromise;
+        invocation.invokeCount++;
+        if (invocation.hasOwnProperty('connection')) {
+            invocationPromise = this.send(invocation, invocation.connection);
+        }
+        else {
+            invocationPromise = this.invokeOnOwner(invocation);
+        }
+        invocationPromise.catch(function (err) {
+            _this.notifyError(invocation, err);
+        });
+    };
+    InvocationService.prototype.invokeOnOwner = function (invocation) {
+        var owner = this.client.getClusterService().getOwnerConnection();
+        if (owner == null) {
+            return Promise.reject(new HazelcastError_1.IOError('Unisocket client\'s owner connection is not available.'));
+        }
+        return this.send(invocation, owner);
+    };
+    InvocationService.prototype.invokeOnAddress = function (invocation, address) {
+        var _this = this;
+        return this.client.getConnectionManager().getOrConnect(address).then(function (connection) {
+            return _this.send(invocation, connection);
+        }).catch(function (e) {
+            _this.logger.debug('InvocationService', e);
+            throw new HazelcastError_1.IOError(address.toString() + ' is not available.', e);
+        });
+    };
+    InvocationService.prototype.invokeOnPartitionOwner = function (invocation, partitionId) {
+        var _this = this;
+        var ownerAddress = this.client.getPartitionService().getAddressForPartition(partitionId);
+        if (!ownerAddress) {
+            // If we don't have partition information, refresh and retry
+            this.logger.debug('InvocationService', "No partition owner for partition " + partitionId + ", refreshing partition table");
+            return this.client.getPartitionService().refresh().then(function () {
+                var newOwnerAddress = _this.client.getPartitionService().getAddressForPartition(partitionId);
+                if (!newOwnerAddress) {
+                    throw new Error("Still no partition owner for partition " + partitionId + " after refresh");
+                }
+                return _this.invokeOnAddress(invocation, newOwnerAddress);
+            });
+        }
+        return this.client.getConnectionManager().getOrConnect(ownerAddress).then(function (connection) {
+            return _this.send(invocation, connection);
+        }).catch(function (e) {
+            _this.logger.debug('InvocationService', "Partition owner " + ownerAddress.toString() + " unavailable for partition " + partitionId + ":", e);
+            // If this is a partition-specific failure, refresh partition table and retry
+            if (invocation.hasPartitionId()) {
+                _this.logger.debug('InvocationService', "Refreshing partition table due to partition owner failure");
+                return _this.client.getPartitionService().refresh().then(function () {
+                    // Retry the invocation with updated partition information
+                    return _this.doInvoke(invocation);
+                });
+            }
+            throw new HazelcastError_1.IOError(ownerAddress.toString() + '(partition owner) is not available.', e);
+        });
+    };
+    InvocationService.prototype.send = function (invocation, connection) {
+        assert(connection != null);
+        if (this.isShutdown) {
+            return Promise.reject(new HazelcastError_1.ClientNotActiveError('Client is shutdown.'));
+        }
+        this.registerInvocation(invocation);
+        return connection.write(invocation.request.getBuffer()).then(function () {
+            invocation.sendConnection = connection;
+        });
+    };
+    InvocationService.prototype.notifyError = function (invocation, error) {
+        var correlationId = invocation.request.getCorrelationId();
+        if (this.rejectIfNotRetryable(invocation, error)) {
+            this.pending.delete(correlationId);
+            return;
+        }
+        // Check if we've exceeded max retry attempts
+        if (invocation.invokeCount >= this.maxRetryAttempts) {
+            this.logger.error('InvocationService', "Max retry attempts (" + this.maxRetryAttempts + ") exceeded for correlation-id=" + correlationId);
+            invocation.deferred.reject(new Error("Max retry attempts exceeded: " + error.message));
+            this.pending.delete(correlationId);
+            return;
+        }
+        this.logger.debug('InvocationService', 'Retrying(' + invocation.invokeCount + ') on correlation-id=' + correlationId, error);
+        // Use exponential backoff for partition failures
+        var retryDelay = this.getInvocationRetryPauseMillis();
+        if (invocation.hasPartitionId() && error instanceof HazelcastError_1.IOError) {
+            retryDelay = this.partitionFailureBackoff;
+        }
+        if (invocation.invokeCount < MAX_FAST_INVOCATION_COUNT) {
+            this.doInvoke(invocation);
+        }
+        else {
+            setTimeout(this.doInvoke.bind(this, invocation), retryDelay);
+        }
+    };
+    /**
+     * Determines if an error is retryable. The given invocation is rejected with approprate error if the error is not retryable.
+     * @param invocation
+     * @param error
+     * @returns `true` if invocation is rejected, `false` otherwise
+     */
+    InvocationService.prototype.rejectIfNotRetryable = function (invocation, error) {
+        if (!this.client.getLifecycleService().isRunning()) {
+            invocation.deferred.reject(new HazelcastError_1.ClientNotActiveError('Client is not active.', error));
+            return true;
+        }
+        if (!invocation.isAllowedToRetryOnSelection(error)) {
+            invocation.deferred.reject(error);
+            return true;
+        }
+        if (!invocation.shouldRetry(error)) {
+            invocation.deferred.reject(error);
+            return true;
+        }
+        if (invocation.deadline < Date.now()) {
+            this.logger.trace('InvocationService', 'Error will not be retried because invocation timed out');
+            invocation.deferred.reject(new HazelcastError_1.InvocationTimeoutError('Invocation ' + invocation.request.getCorrelationId() + ')'
+                + ' reached its deadline.', error));
+            return true;
+        }
+    };
+    InvocationService.prototype.registerInvocation = function (invocation) {
+        var message = invocation.request;
+        var correlationId = message.getCorrelationId();
+        if (invocation.hasPartitionId()) {
+            message.setPartitionId(invocation.partitionId);
+        }
+        else {
+            message.setPartitionId(-1);
+        }
+        if (invocation.hasOwnProperty('handler')) {
+            this.eventHandlers.set(correlationId, invocation);
+        }
+        this.pending.set(correlationId, invocation);
+    };
+    return InvocationService;
+}());
+exports.InvocationService = InvocationService;

package/lib/invocation/Murmur.d.ts

@@ -0,0 +1,2 @@
+declare function murmurhash3_32_gc(key: any): number;
+export = murmurhash3_32_gc;

package/lib/invocation/Murmur.js

@@ -0,0 +1,65 @@
+"use strict";
+/*
+ * Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved.
+ *
+ * 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.
+ */
+/* tslint:disable */
+var seed = 0x01000193;
+function murmurhash3_32_gc(key) {
+    var remainder, bytes, h1, h1b, c1, c2, k1, i;
+    remainder = key.length & 3; // key.length % 4
+    bytes = key.length - remainder;
+    h1 = seed;
+    c1 = 0xcc9e2d51;
+    c2 = 0x1b873593;
+    i = 0;
+    while (i < bytes) {
+        k1 =
+            ((key.readUInt8(i) & 0xff)) |
+                ((key.readUInt8(++i) & 0xff) << 8) |
+                ((key.readUInt8(++i) & 0xff) << 16) |
+                ((key.readUInt8(++i) & 0xff) << 24);
+        ++i;
+        k1 = ((((k1 & 0xffff) * c1) + ((((k1 >>> 16) * c1) & 0xffff) << 16))) & 0xffffffff;
+        k1 = (k1 << 15) | (k1 >>> 17);
+        k1 = ((((k1 & 0xffff) * c2) + ((((k1 >>> 16) * c2) & 0xffff) << 16))) & 0xffffffff;
+        h1 ^= k1;
+        h1 = (h1 << 13) | (h1 >>> 19);
+        h1b = ((((h1 & 0xffff) * 5) + ((((h1 >>> 16) * 5) & 0xffff) << 16))) & 0xffffffff;
+        h1 = (((h1b & 0xffff) + 0x6b64) + ((((h1b >>> 16) + 0xe654) & 0xffff) << 16));
+    }
+    k1 = 0;
+    switch (remainder) {
+        case 3:
+            k1 ^= (key.readUInt8(i + 2) & 0xff) << 16;
+        case 2:
+            k1 ^= (key.readUInt8(i + 1) & 0xff) << 8;
+        case 1:
+            k1 ^= (key.readUInt8(i) & 0xff);
+            k1 = (((k1 & 0xffff) * c1) + ((((k1 >>> 16) * c1) & 0xffff) << 16)) & 0xffffffff;
+            k1 = (k1 << 15) | (k1 >>> 17);
+            k1 = (((k1 & 0xffff) * c2) + ((((k1 >>> 16) * c2) & 0xffff) << 16)) & 0xffffffff;
+            h1 ^= k1;
+    }
+    h1 ^= key.length;
+    h1 ^= h1 >>> 16;
+    h1 = (((h1 & 0xffff) * 0x85ebca6b) + ((((h1 >>> 16) * 0x85ebca6b) & 0xffff) << 16)) & 0xffffffff;
+    h1 ^= h1 >>> 13;
+    h1 = ((((h1 & 0xffff) * 0xc2b2ae35) + ((((h1 >>> 16) * 0xc2b2ae35) & 0xffff) << 16))) & 0xffffffff;
+    h1 ^= h1 >>> 16;
+    var result = h1 >>> 0;
+    // This simulates the 32 bit integer overflow to match Java implementation
+    return result | 0;
+}
+module.exports = murmurhash3_32_gc;

package/lib/invocation/RegistrationKey.d.ts

@@ -0,0 +1,16 @@
+import ClientMessage = require('../ClientMessage');
+import { ListenerMessageCodec } from '../ListenerMessageCodec';
+export declare class RegistrationKey {
+    private readonly userRegistrationId;
+    private registerHandlerFunc;
+    private registerRequest;
+    private codec;
+    constructor(regId: string, codec: ListenerMessageCodec, registerRequest?: ClientMessage, registerHandlerFunc?: Function);
+    getRegisterRequest(): ClientMessage;
+    setRegisterRequest(registerRequest: ClientMessage): void;
+    getCodec(): ListenerMessageCodec;
+    setCodec(value: ListenerMessageCodec): void;
+    getHandler(): Function;
+    setHandler(handler: Function): void;
+    getUserRegistrationKey(): string;
+}

package/lib/invocation/RegistrationKey.js

@@ -0,0 +1,48 @@
+"use strict";
+/*
+ * Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved.
+ *
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+var RegistrationKey = /** @class */ (function () {
+    function RegistrationKey(regId, codec, registerRequest, registerHandlerFunc) {
+        this.userRegistrationId = regId;
+        this.registerHandlerFunc = registerHandlerFunc;
+        this.registerRequest = registerRequest;
+        this.codec = codec;
+    }
+    RegistrationKey.prototype.getRegisterRequest = function () {
+        return this.registerRequest;
+    };
+    RegistrationKey.prototype.setRegisterRequest = function (registerRequest) {
+        this.registerRequest = registerRequest;
+    };
+    RegistrationKey.prototype.getCodec = function () {
+        return this.codec;
+    };
+    RegistrationKey.prototype.setCodec = function (value) {
+        this.codec = value;
+    };
+    RegistrationKey.prototype.getHandler = function () {
+        return this.registerHandlerFunc;
+    };
+    RegistrationKey.prototype.setHandler = function (handler) {
+        this.registerHandlerFunc = handler;
+    };
+    RegistrationKey.prototype.getUserRegistrationKey = function () {
+        return this.userRegistrationId;
+    };
+    return RegistrationKey;
+}());
+exports.RegistrationKey = RegistrationKey;

package/lib/logging/DefaultLogger.d.ts

@@ -0,0 +1,12 @@
+import { LogLevel } from './LoggingService';
+import { ILogger } from './ILogger';
+export declare class DefaultLogger implements ILogger {
+    private readonly level;
+    constructor(level: number);
+    log(level: LogLevel, objectName: string, message: string, furtherInfo: any): void;
+    error(objectName: string, message: string, furtherInfo?: any): void;
+    warn(objectName: string, message: string, furtherInfo?: any): void;
+    info(objectName: string, message: string, furtherInfo?: any): void;
+    debug(objectName: string, message: string, furtherInfo?: any): void;
+    trace(objectName: string, message: string, furtherInfo?: any): void;
+}

package/lib/logging/DefaultLogger.js

@@ -0,0 +1,48 @@
+"use strict";
+/*
+ * Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved.
+ *
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+var LoggingService_1 = require("./LoggingService");
+var DefaultLogger = /** @class */ (function () {
+    function DefaultLogger(level) {
+        this.level = level;
+    }
+    DefaultLogger.prototype.log = function (level, objectName, message, furtherInfo) {
+        if (level <= this.level) {
+            console.log('[DefaultLogger] %s at %s: %s', LoggingService_1.LogLevel[level], objectName, message);
+            if (furtherInfo != null) {
+                console.log(furtherInfo);
+            }
+        }
+    };
+    DefaultLogger.prototype.error = function (objectName, message, furtherInfo) {
+        this.log(LoggingService_1.LogLevel.ERROR, objectName, message, furtherInfo);
+    };
+    DefaultLogger.prototype.warn = function (objectName, message, furtherInfo) {
+        this.log(LoggingService_1.LogLevel.WARN, objectName, message, furtherInfo);
+    };
+    DefaultLogger.prototype.info = function (objectName, message, furtherInfo) {
+        this.log(LoggingService_1.LogLevel.INFO, objectName, message, furtherInfo);
+    };
+    DefaultLogger.prototype.debug = function (objectName, message, furtherInfo) {
+        this.log(LoggingService_1.LogLevel.DEBUG, objectName, message, furtherInfo);
+    };
+    DefaultLogger.prototype.trace = function (objectName, message, furtherInfo) {
+        this.log(LoggingService_1.LogLevel.TRACE, objectName, message, furtherInfo);
+    };
+    return DefaultLogger;
+}());
+exports.DefaultLogger = DefaultLogger;

package/lib/logging/ILogger.d.ts

@@ -0,0 +1,49 @@
+import { LogLevel } from './LoggingService';
+/**
+ * The Hazelcast logging interface.
+ */
+export interface ILogger {
+    /**
+     * Logs a message with an associated objectName and furtherInfo at the given level.
+     * @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 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 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 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 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 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;
+}

package/lib/logging/ILogger.js

@@ -0,0 +1,17 @@
+"use strict";
+/*
+ * Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved.
+ *
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/logging/LoggingService.d.ts

@@ -0,0 +1,16 @@
+import { Property } from '../config/Properties';
+import { ILogger } from './ILogger';
+export declare enum LogLevel {
+    OFF = -1,
+    ERROR = 0,
+    WARN = 1,
+    INFO = 2,
+    DEBUG = 3,
+    TRACE = 4,
+}
+export declare class LoggingService {
+    private readonly logger;
+    constructor(customLogger: ILogger, logLevel: number);
+    isLogger(loggingProperty: Property): loggingProperty is ILogger;
+    getLogger(): ILogger;
+}