pulsar-client 1.1.0 → 1.2.1

package/.asf.yaml

@@ -0,0 +1,46 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you 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.
+#
+
+github:
+  description: "Apache Pulsar NodeJS Client"
+  homepage: https://pulsar.apache.org/
+  labels:
+    - pulsar
+    - pubsub
+    - messaging
+    - streaming
+    - queuing
+    - event-streaming
+    - node
+    - javascript
+    - nodejs
+  features:
+    # Enable wiki for documentation
+    wiki: true
+    # Enable issues management
+    issues: true
+    # Enable projects for project management boards
+    projects: true
+  enabled_merge_buttons:
+    # enable squash button:
+    squash:  true
+    # disable merge button:
+    merge:   false
+    # disable rebase button:
+    rebase:  false

package/.eslintrc.json

@@ -6,6 +6,14 @@
     "no-console": "off",
     "no-unused-vars": "warn"
   },
+  "overrides": [
+    {
+      "files": ["tests/*.js"],
+      "rules": {
+        "no-await-in-loop": "off"
+      }
+    }
+  ],
   "globals": {
     "describe": true,
     "test": true,

package/README.md

@@ -44,6 +44,7 @@ Compatibility between each version of the Node.js client and the C++ client is a
 |----------------|----------------|
 | 1.0.0          | 2.3.0 or later |
 | 1.1.0          | 2.4.0 or later |
+| 1.2.0          | 2.5.0 or later |
 
 If an incompatible version of the C++ client is installed, you may fail to build or run this library.
 

package/examples/consumer_listener.js

@@ -0,0 +1,40 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.
+ */
+
+const Pulsar = require('pulsar-client');
+
+(async () => {
+  // Create a client
+  const client = new Pulsar.Client({
+    serviceUrl: 'pulsar://localhost:6650',
+    operationTimeoutSeconds: 30,
+  });
+
+  // Create a consumer with listener
+  const consumer = await client.subscribe({
+    topic: 'persistent://public/default/my-topic',
+    subscription: 'sub1',
+    subscriptionType: 'Shared',
+    ackTimeoutMs: 10000,
+    listener: (msg, msgConsumer) => {
+      console.log(msg.getData().toString());
+      msgConsumer.acknowledge(msg);
+    },
+  });
+})();

package/index.js

@@ -22,6 +22,13 @@ const AuthenticationTls = require('./src/AuthenticationTls.js');
 const AuthenticationAthenz = require('./src/AuthenticationAthenz.js');
 const AuthenticationToken = require('./src/AuthenticationToken.js');
 
+const LogLevel = {
+  DEBUG: 0,
+  INFO: 1,
+  WARN: 2,
+  ERROR: 3,
+};
+
 const Pulsar = {
   Client: PulsarBinding.Client,
   Message: PulsarBinding.Message,
@@ -29,6 +36,7 @@ const Pulsar = {
   AuthenticationTls,
   AuthenticationAthenz,
   AuthenticationToken,
+  LogLevel,
 };
 
 module.exports = Pulsar;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pulsar-client",
-  "version": "1.1.0",
+  "version": "1.2.1",
   "description": "Pulsar Node.js client",
   "main": "index.js",
   "directories": {
@@ -11,8 +11,8 @@
     "install": "node-pre-gyp install --fallback-to-build",
     "clean": "node-gyp clean",
     "configure": "node-gyp configure",
-    "lint": "eslint --ext .js .",
-    "format": "clang-format -i --verbose src/* && eslint --fix --ext .js .",
+    "lint": "clang-format-lint src/*.cc src/*.h && eslint --ext .js .",
+    "format": "clang-format-lint --fix src/*.cc src/*.h && eslint --fix --ext .js .",
     "build": "npm run format && node-gyp rebuild",
     "build:debug": "npm run format && node-gyp rebuild --debug",
     "license:report": "mkdir -p report && grunt grunt-license-report",
@@ -30,6 +30,7 @@
     "node": ">=10.16.0"
   },
   "devDependencies": {
+    "@seadub/clang-format-lint": "0.0.2",
     "clang-format": "^1.2.4",
     "commander": "^2.20.0",
     "delay": "^4.3.0",
@@ -41,7 +42,7 @@
     "hdr-histogram-js": "^1.1.4",
     "jest": "^24.8.0",
     "license-check-and-add": "^2.3.6",
-    "lodash": "^4.17.15"
+    "lodash": "^4.17.19"
   },
   "dependencies": {
     "bindings": "^1.3.1",

package/pulsar-version.txt

@@ -1 +1 @@
-2.4.0
+2.5.0

package/run-unit-tests.sh

@@ -33,7 +33,7 @@ done;
 apt install $PULSAR_PKG_DIR/apache-pulsar-client*.deb
 
 ./pulsar-test-service-start.sh
-npm install && npm run build && npm run test
+npm install && npm run lint && npm run build && npm run test
 RES=$?
 ./pulsar-test-service-stop.sh
 

package/src/Client.cc

@@ -38,6 +38,7 @@ static const std::string CFG_TLS_TRUST_CERT = "tlsTrustCertsFilePath";
 static const std::string CFG_TLS_VALIDATE_HOSTNAME = "tlsValidateHostname";
 static const std::string CFG_TLS_ALLOW_INSECURE = "tlsAllowInsecureConnection";
 static const std::string CFG_STATS_INTERVAL = "statsIntervalInSeconds";
+static const std::string CFG_LOG = "log";
 
 Napi::FunctionReference Client::constructor;
 
@@ -73,6 +74,17 @@ Client::Client(const Napi::CallbackInfo &info) : Napi::ObjectWrap<Client>(info)
 
   pulsar_client_configuration_t *cClientConfig = pulsar_client_configuration_create();
 
+  if (clientConfig.Has(CFG_LOG) && clientConfig.Get(CFG_LOG).IsFunction()) {
+    Napi::ThreadSafeFunction logFunction = Napi::ThreadSafeFunction::New(
+        env, clientConfig.Get(CFG_LOG).As<Napi::Function>(), "Pulsar Logging", 0, 1);
+    this->logCallback = new LogCallback();
+    this->logCallback->callback = logFunction;
+
+    pulsar_client_configuration_set_logger(cClientConfig, &LogMessage, this->logCallback);
+  } else {
+    this->logCallback = nullptr;
+  }
+
   if (clientConfig.Has(CFG_AUTH) && clientConfig.Get(CFG_AUTH).IsObject()) {
     Napi::Object obj = clientConfig.Get(CFG_AUTH).ToObject();
     if (obj.Has(CFG_AUTH_PROP) && obj.Get(CFG_AUTH_PROP).IsObject()) {
@@ -139,14 +151,20 @@ Client::Client(const Napi::CallbackInfo &info) : Napi::ObjectWrap<Client>(info)
 
   this->cClient = pulsar_client_create(serviceUrl.Utf8Value().c_str(), cClientConfig);
   pulsar_client_configuration_free(cClientConfig);
+  this->Ref();
 }
 
-Client::~Client() { pulsar_client_free(this->cClient); }
+Client::~Client() {
+  pulsar_client_free(this->cClient);
+  if (this->logCallback != nullptr) {
+    this->logCallback->callback.Release();
+    this->logCallback = nullptr;
+  }
+}
 
 Napi::Value Client::CreateProducer(const Napi::CallbackInfo &info) {
   return Producer::NewInstance(info, this->cClient);
 }
-
 Napi::Value Client::Subscribe(const Napi::CallbackInfo &info) {
   return Consumer::NewInstance(info, this->cClient);
 }
@@ -155,6 +173,29 @@ Napi::Value Client::CreateReader(const Napi::CallbackInfo &info) {
   return Reader::NewInstance(info, this->cClient);
 }
 
+void LogMessageProxy(Napi::Env env, Napi::Function jsCallback, struct LogMessage *logMessage) {
+  Napi::Number logLevel = Napi::Number::New(env, static_cast<double>(logMessage->level));
+  Napi::String file = Napi::String::New(env, logMessage->file);
+  Napi::Number line = Napi::Number::New(env, static_cast<double>(logMessage->line));
+  Napi::String message = Napi::String::New(env, logMessage->message);
+
+  delete logMessage;
+  jsCallback.Call({logLevel, file, line, message});
+}
+
+void LogMessage(pulsar_logger_level_t level, const char *file, int line, const char *message, void *ctx) {
+  LogCallback *logCallback = (LogCallback *)ctx;
+
+  if (logCallback->callback.Acquire() != napi_ok) {
+    return;
+  }
+
+  struct LogMessage *logMessage = new struct LogMessage(level, std::string(file), line, std::string(message));
+
+  logCallback->callback.BlockingCall(logMessage, LogMessageProxy);
+  logCallback->callback.Release();
+}
+
 class ClientCloseWorker : public Napi::AsyncWorker {
  public:
   ClientCloseWorker(const Napi::Promise::Deferred &deferred, pulsar_client_t *cClient)
@@ -178,6 +219,8 @@ class ClientCloseWorker : public Napi::AsyncWorker {
 };
 
 Napi::Value Client::Close(const Napi::CallbackInfo &info) {
+  this->Unref();
+
   Napi::Promise::Deferred deferred = Napi::Promise::Deferred::New(info.Env());
   ClientCloseWorker *wk = new ClientCloseWorker(deferred, this->cClient);
   wk->Queue();

package/src/Client.h

@@ -23,15 +23,33 @@
 #include <napi.h>
 #include <pulsar/c/client.h>
 
+struct LogMessage {
+  pulsar_logger_level_t level;
+  std::string file;
+  int line;
+  std::string message;
+
+  LogMessage(pulsar_logger_level_t level, std::string file, int line, std::string message)
+      : level(level), file(file), line(line), message(message) {}
+};
+
+struct LogCallback {
+  Napi::ThreadSafeFunction callback;
+};
+
+void LogMessage(pulsar_logger_level_t level, const char *file, int line, const char *message, void *ctx);
+
 class Client : public Napi::ObjectWrap<Client> {
  public:
   static Napi::Object Init(Napi::Env env, Napi::Object exports);
+
   Client(const Napi::CallbackInfo &info);
   ~Client();
 
  private:
   static Napi::FunctionReference constructor;
   pulsar_client_t *cClient;
+  LogCallback *logCallback;
 
   Napi::Value CreateProducer(const Napi::CallbackInfo &info);
   Napi::Value Subscribe(const Napi::CallbackInfo &info);

package/src/Consumer.cc

@@ -45,8 +45,49 @@ void Consumer::Init(Napi::Env env, Napi::Object exports) {
   constructor.SuppressDestruct();
 }
 
+struct MessageListenerProxyData {
+  pulsar_message_t *cMessage;
+  Consumer *consumer;
+
+  MessageListenerProxyData(pulsar_message_t *cMessage, Consumer *consumer)
+      : cMessage(cMessage), consumer(consumer) {}
+};
+
+void MessageListenerProxy(Napi::Env env, Napi::Function jsCallback, MessageListenerProxyData *data) {
+  Napi::Object msg = Message::NewInstance({}, data->cMessage);
+  Consumer *consumer = data->consumer;
+  delete data;
+
+  jsCallback.Call({msg, consumer->Value()});
+}
+
+void MessageListener(pulsar_consumer_t *cConsumer, pulsar_message_t *cMessage, void *ctx) {
+  ListenerCallback *listenerCallback = (ListenerCallback *)ctx;
+
+  Consumer *consumer = (Consumer *)listenerCallback->consumer;
+
+  if (listenerCallback->callback.Acquire() != napi_ok) {
+    return;
+  }
+
+  MessageListenerProxyData *dataPtr = new MessageListenerProxyData(cMessage, consumer);
+  listenerCallback->callback.BlockingCall(dataPtr, MessageListenerProxy);
+  listenerCallback->callback.Release();
+}
+
 void Consumer::SetCConsumer(std::shared_ptr<CConsumerWrapper> cConsumer) { this->wrapper = cConsumer; }
-void Consumer::SetListenerCallback(ListenerCallback *listener) { this->listener = listener; }
+void Consumer::SetListenerCallback(ListenerCallback *listener) {
+  if (listener) {
+    // Maintain reference to consumer, so it won't get garbage collected
+    // since, when we have a listener, we don't have to maintain reference to consumer (in js code)
+    this->Ref();
+
+    // Pass consumer as argument
+    listener->consumer = this;
+  }
+
+  this->listener = listener;
+}
 
 Consumer::Consumer(const Napi::CallbackInfo &info) : Napi::ObjectWrap<Consumer>(info), listener(nullptr) {}
 
@@ -100,6 +141,7 @@ class ConsumerNewInstanceWorker : public Napi::AsyncWorker {
   void OnOK() {
     Napi::Object obj = Consumer::constructor.New({});
     Consumer *consumer = Consumer::Unwrap(obj);
+
     consumer->SetCConsumer(this->consumerWrapper);
     consumer->SetListenerCallback(this->listener);
     this->deferred.Resolve(obj);
@@ -118,8 +160,10 @@ class ConsumerNewInstanceWorker : public Napi::AsyncWorker {
 Napi::Value Consumer::NewInstance(const Napi::CallbackInfo &info, pulsar_client_t *cClient) {
   Napi::Promise::Deferred deferred = Napi::Promise::Deferred::New(info.Env());
   Napi::Object config = info[0].As<Napi::Object>();
+
   std::shared_ptr<CConsumerWrapper> consumerWrapper = std::make_shared<CConsumerWrapper>();
-  ConsumerConfig *consumerConfig = new ConsumerConfig(config, consumerWrapper);
+
+  ConsumerConfig *consumerConfig = new ConsumerConfig(config, consumerWrapper, &MessageListener);
   ConsumerNewInstanceWorker *wk =
       new ConsumerNewInstanceWorker(deferred, cClient, consumerConfig, consumerWrapper);
   wk->Queue();
@@ -213,17 +257,25 @@ void Consumer::AcknowledgeCumulativeId(const Napi::CallbackInfo &info) {
 
 class ConsumerCloseWorker : public Napi::AsyncWorker {
  public:
-  ConsumerCloseWorker(const Napi::Promise::Deferred &deferred, pulsar_consumer_t *cConsumer)
+  ConsumerCloseWorker(const Napi::Promise::Deferred &deferred, pulsar_consumer_t *cConsumer,
+                      Consumer *consumer)
       : AsyncWorker(Napi::Function::New(deferred.Promise().Env(), [](const Napi::CallbackInfo &info) {})),
         deferred(deferred),
-        cConsumer(cConsumer) {}
+        cConsumer(cConsumer),
+        consumer(consumer) {}
+
   ~ConsumerCloseWorker() {}
   void Execute() {
     pulsar_consumer_pause_message_listener(this->cConsumer);
     pulsar_result result = pulsar_consumer_close(this->cConsumer);
-    if (result != pulsar_result_Ok) SetError(pulsar_result_str(result));
+    if (result != pulsar_result_Ok) {
+      SetError(pulsar_result_str(result));
+    }
+  }
+  void OnOK() {
+    this->consumer->Cleanup();
+    this->deferred.Resolve(Env().Null());
   }
-  void OnOK() { this->deferred.Resolve(Env().Null()); }
   void OnError(const Napi::Error &e) {
     this->deferred.Reject(
         Napi::Error::New(Env(), std::string("Failed to close consumer: ") + e.Message()).Value());
@@ -232,18 +284,31 @@ class ConsumerCloseWorker : public Napi::AsyncWorker {
  private:
   Napi::Promise::Deferred deferred;
   pulsar_consumer_t *cConsumer;
+  Consumer *consumer;
 };
 
+void Consumer::Cleanup() {
+  if (this->listener) {
+    this->CleanupListener();
+  }
+}
+
+void Consumer::CleanupListener() {
+  pulsar_consumer_pause_message_listener(this->wrapper->cConsumer);
+  this->Unref();
+  this->listener->callback.Release();
+  this->listener = nullptr;
+}
+
 Napi::Value Consumer::Close(const Napi::CallbackInfo &info) {
   Napi::Promise::Deferred deferred = Napi::Promise::Deferred::New(info.Env());
-  ConsumerCloseWorker *wk = new ConsumerCloseWorker(deferred, this->wrapper->cConsumer);
+  ConsumerCloseWorker *wk = new ConsumerCloseWorker(deferred, this->wrapper->cConsumer, this);
   wk->Queue();
   return deferred.Promise();
 }
 
 Consumer::~Consumer() {
   if (this->listener) {
-    pulsar_consumer_pause_message_listener(this->wrapper->cConsumer);
-    this->listener->callback.Release();
+    this->CleanupListener();
   }
 }

package/src/Consumer.h

@@ -23,6 +23,7 @@
 #include <napi.h>
 #include <pulsar/c/client.h>
 #include "ConsumerConfig.h"
+#include "MessageListener.h"
 
 class Consumer : public Napi::ObjectWrap<Consumer> {
  public:
@@ -33,6 +34,8 @@ class Consumer : public Napi::ObjectWrap<Consumer> {
   ~Consumer();
   void SetCConsumer(std::shared_ptr<CConsumerWrapper> cConsumer);
   void SetListenerCallback(ListenerCallback *listener);
+  void Cleanup();
+  void CleanupListener();
 
  private:
   std::shared_ptr<CConsumerWrapper> wrapper;

package/src/ConsumerConfig.cc

@@ -35,47 +35,22 @@ static const std::string CFG_RECV_QUEUE_ACROSS_PARTITIONS = "receiverQueueSizeAc
 static const std::string CFG_CONSUMER_NAME = "consumerName";
 static const std::string CFG_PROPS = "properties";
 static const std::string CFG_LISTENER = "listener";
+static const std::string CFG_READ_COMPACTED = "readCompacted";
 
 static const std::map<std::string, pulsar_consumer_type> SUBSCRIPTION_TYPE = {
     {"Exclusive", pulsar_ConsumerExclusive},
     {"Shared", pulsar_ConsumerShared},
+    {"KeyShared", pulsar_ConsumerKeyShared},
     {"Failover", pulsar_ConsumerFailover}};
 
 static const std::map<std::string, initial_position> INIT_POSITION = {
     {"Latest", initial_position_latest}, {"Earliest", initial_position_earliest}};
 
-struct MessageListenerProxyData {
-  std::shared_ptr<CConsumerWrapper> consumerWrapper;
-  pulsar_message_t *cMessage;
-
-  MessageListenerProxyData(std::shared_ptr<CConsumerWrapper> consumerWrapper, pulsar_message_t *cMessage)
-      : consumerWrapper(consumerWrapper), cMessage(cMessage) {}
-};
-
-void MessageListenerProxy(Napi::Env env, Napi::Function jsCallback, MessageListenerProxyData *data) {
-  Napi::Object msg = Message::NewInstance({}, data->cMessage);
-  Napi::Object consumerObj = Consumer::constructor.New({});
-  Consumer *consumer = Consumer::Unwrap(consumerObj);
-  consumer->SetCConsumer(std::move(data->consumerWrapper));
-  delete data;
-  jsCallback.Call({msg, consumerObj});
-}
-
-void MessageListener(pulsar_consumer_t *cConsumer, pulsar_message_t *cMessage, void *ctx) {
-  ListenerCallback *listenerCallback = (ListenerCallback *)ctx;
-  if (listenerCallback->callback.Acquire() != napi_ok) {
-    return;
-  };
-  MessageListenerProxyData *dataPtr =
-      new MessageListenerProxyData(listenerCallback->consumerWrapper, cMessage);
-  listenerCallback->callback.BlockingCall(dataPtr, MessageListenerProxy);
-  listenerCallback->callback.Release();
-}
-
 void FinalizeListenerCallback(Napi::Env env, ListenerCallback *cb, void *) { delete cb; }
 
 ConsumerConfig::ConsumerConfig(const Napi::Object &consumerConfig,
-                               std::shared_ptr<CConsumerWrapper> consumerWrapper)
+                               std::shared_ptr<CConsumerWrapper> consumerWrapper,
+                               pulsar_message_listener messageListener)
     : topic(""), subscription(""), ackTimeoutMs(0), nAckRedeliverTimeoutMs(60000), listener(nullptr) {
   this->cConsumerConfig = pulsar_consumer_configuration_create();
 
@@ -154,14 +129,20 @@ ConsumerConfig::ConsumerConfig(const Napi::Object &consumerConfig,
 
   if (consumerConfig.Has(CFG_LISTENER) && consumerConfig.Get(CFG_LISTENER).IsFunction()) {
     this->listener = new ListenerCallback();
-    this->listener->consumerWrapper = consumerWrapper;
     Napi::ThreadSafeFunction callback = Napi::ThreadSafeFunction::New(
         consumerConfig.Env(), consumerConfig.Get(CFG_LISTENER).As<Napi::Function>(), "Listener Callback", 1,
         1, (void *)NULL, FinalizeListenerCallback, listener);
     this->listener->callback = std::move(callback);
-    pulsar_consumer_configuration_set_message_listener(this->cConsumerConfig, &MessageListener,
+    pulsar_consumer_configuration_set_message_listener(this->cConsumerConfig, messageListener,
                                                        this->listener);
   }
+
+  if (consumerConfig.Has(CFG_READ_COMPACTED) && consumerConfig.Get(CFG_READ_COMPACTED).IsBoolean()) {
+    bool readCompacted = consumerConfig.Get(CFG_READ_COMPACTED).ToBoolean();
+    if (readCompacted) {
+      pulsar_consumer_set_read_compacted(this->cConsumerConfig, 1);
+    }
+  }
 }
 
 ConsumerConfig::~ConsumerConfig() {

package/src/ConsumerConfig.h

@@ -20,31 +20,22 @@
 #ifndef CONSUMER_CONFIG_H
 #define CONSUMER_CONFIG_H
 
-#include <napi.h>
 #include <pulsar/c/consumer_configuration.h>
+#include "MessageListener.h"
 
 #define MIN_ACK_TIMEOUT_MILLIS 10000
 
-struct CConsumerWrapper {
-  pulsar_consumer_t *cConsumer;
-  CConsumerWrapper();
-  ~CConsumerWrapper();
-};
-
-struct ListenerCallback {
-  Napi::ThreadSafeFunction callback;
-  std::shared_ptr<CConsumerWrapper> consumerWrapper;
-};
-
 class ConsumerConfig {
  public:
-  ConsumerConfig(const Napi::Object &consumerConfig, std::shared_ptr<CConsumerWrapper> consumerWrapper);
+  ConsumerConfig(const Napi::Object &consumerConfig, std::shared_ptr<CConsumerWrapper> consumerWrapper,
+                 pulsar_message_listener messageListener);
   ~ConsumerConfig();
   pulsar_consumer_configuration_t *GetCConsumerConfig();
   std::string GetTopic();
   std::string GetSubscription();
   int64_t GetAckTimeoutMs();
   int64_t GetNAckRedeliverTimeoutMs();
+
   ListenerCallback *GetListenerCallback();
 
  private:

package/src/Message.cc

@@ -40,6 +40,7 @@ Napi::Object Message::Init(Napi::Env env, Napi::Object exports) {
        InstanceMethod("getMessageId", &Message::GetMessageId),
        InstanceMethod("getPublishTimestamp", &Message::GetPublishTimestamp),
        InstanceMethod("getEventTimestamp", &Message::GetEventTimestamp),
+       InstanceMethod("getRedeliveryCount", &Message::GetRedeliveryCount),
        InstanceMethod("getPartitionKey", &Message::GetPartitionKey)});
 
   constructor = Napi::Persistent(func);
@@ -68,6 +69,14 @@ Napi::Value Message::GetTopicName(const Napi::CallbackInfo &info) {
   return Napi::String::New(env, pulsar_message_get_topic_name(this->cMessage));
 }
 
+Napi::Value Message::GetRedeliveryCount(const Napi::CallbackInfo &info) {
+  Napi::Env env = info.Env();
+  if (!ValidateCMessage(env)) {
+    return env.Null();
+  }
+  return Napi::Number::New(env, pulsar_message_get_redelivery_count(this->cMessage));
+}
+
 Napi::Value Message::GetProperties(const Napi::CallbackInfo &info) {
   Napi::Env env = info.Env();
   if (!ValidateCMessage(env)) {

package/src/Message.h

@@ -44,6 +44,7 @@ class Message : public Napi::ObjectWrap<Message> {
   Napi::Value GetPublishTimestamp(const Napi::CallbackInfo &info);
   Napi::Value GetEventTimestamp(const Napi::CallbackInfo &info);
   Napi::Value GetPartitionKey(const Napi::CallbackInfo &info);
+  Napi::Value GetRedeliveryCount(const Napi::CallbackInfo &info);
   bool ValidateCMessage(Napi::Env env);
 
   static char **NewStringArray(int size) { return (char **)calloc(sizeof(char *), size); }

package/src/MessageListener.h

@@ -0,0 +1,39 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.
+ */
+
+#ifndef MESSAGELISTENER_H
+#define MESSAGELISTENER_H
+
+#include <napi.h>
+#include <pulsar/c/client.h>
+
+struct CConsumerWrapper {
+  pulsar_consumer_t *cConsumer;
+  CConsumerWrapper();
+  ~CConsumerWrapper();
+};
+
+struct ListenerCallback {
+  Napi::ThreadSafeFunction callback;
+
+  // Using consumer as void* since the ListenerCallback is shared between Config and Consumer.
+  void *consumer;
+};
+
+#endif

package/src/ReaderConfig.cc

@@ -26,6 +26,7 @@ static const std::string CFG_START_MESSAGE_ID = "startMessageId";
 static const std::string CFG_RECV_QUEUE = "receiverQueueSize";
 static const std::string CFG_READER_NAME = "readerName";
 static const std::string CFG_SUBSCRIPTION_ROLE_PREFIX = "subscriptionRolePrefix";
+static const std::string CFG_READ_COMPACTED = "readCompacted";
 
 ReaderConfig::ReaderConfig(const Napi::Object &readerConfig) : topic(""), cStartMessageId(NULL) {
   this->cReaderConfig = pulsar_reader_configuration_create();
@@ -59,6 +60,13 @@ ReaderConfig::ReaderConfig(const Napi::Object &readerConfig) : topic(""), cStart
     if (!subscriptionRolePrefix.empty())
       pulsar_reader_configuration_set_reader_name(this->cReaderConfig, subscriptionRolePrefix.c_str());
   }
+
+  if (readerConfig.Has(CFG_READ_COMPACTED) && readerConfig.Get(CFG_READ_COMPACTED).IsBoolean()) {
+    bool readCompacted = readerConfig.Get(CFG_READ_COMPACTED).ToBoolean();
+    if (readCompacted) {
+      pulsar_reader_configuration_set_read_compacted(this->cReaderConfig, 1);
+    }
+  }
 }
 
 ReaderConfig::~ReaderConfig() { pulsar_reader_configuration_free(this->cReaderConfig); }

package/tests/conf/standalone.conf

@@ -78,6 +78,8 @@ statusFilePath=/usr/local/apache/htdocs
 # Using a value of 0, is disabling unackeMessage limit check and consumer can receive messages without any restriction
 maxUnackedMessagesPerConsumer=50000
 
+subscriptionRedeliveryTrackerEnabled=true
+
 ### --- Authentication --- ###
 
 # Enable authentication

package/tests/consumer.test.js

@@ -87,5 +87,22 @@ const Pulsar = require('../index.js');
         })).rejects.toThrow('NAck timeout should be greater than or equal to zero');
       });
     });
+
+    describe('Close', () => {
+      test('throws error on subsequent calls to close', async () => {
+        const consumer = await client.subscribe({
+          topic: 'persistent://public/default/my-topic',
+          subscription: 'sub1',
+          subscriptionType: 'Shared',
+          // Test with listener since it changes the flow of close
+          // and reproduces an issue
+          listener() {},
+        });
+
+        await expect(consumer.close()).resolves.toEqual(null);
+
+        await expect(consumer.close()).rejects.toThrow('Failed to close consumer: AlreadyClosed');
+      });
+    });
   });
 })();

package/tests/end_to_end.test.js

@@ -116,6 +116,52 @@ const Pulsar = require('../index.js');
       await client.close();
     });
 
+    test('getRedeliveryCount', async () => {
+      const client = new Pulsar.Client({
+        serviceUrl: 'pulsar://localhost:6650',
+        operationTimeoutSeconds: 30,
+      });
+
+      const topic = 'persistent://public/default/produce-consume';
+      const producer = await client.createProducer({
+        topic,
+        sendTimeoutMs: 30000,
+        batchingEnabled: true,
+      });
+      expect(producer).not.toBeNull();
+
+      const consumer = await client.subscribe({
+        topic,
+        subscriptionType: 'Shared',
+        subscription: 'sub1',
+        ackTimeoutMs: 10000,
+        nAckRedeliverTimeoutMs: 100,
+      });
+
+      expect(consumer).not.toBeNull();
+
+      const message = 'my-message';
+      producer.send({
+        data: Buffer.from(message),
+      });
+      await producer.flush();
+
+      let redeliveryCount;
+      let msg;
+      for (let index = 0; index < 3; index += 1) {
+        msg = await consumer.receive();
+        redeliveryCount = msg.getRedeliveryCount();
+        consumer.negativeAcknowledge(msg);
+      }
+      expect(redeliveryCount).toBe(2);
+      consumer.acknowledge(msg);
+
+      await producer.close();
+      await consumer.close();
+      await client.close();
+    });
+
+
     test('Produce/Consume Listener', async () => {
       const client = new Pulsar.Client({
         serviceUrl: 'pulsar://localhost:6650',