pulsar-client 1.12.0 → 1.13.0-rc.3

package/.github/workflows/ci-build-release-napi.yml

@@ -83,7 +83,7 @@ jobs:
           npx node-pre-gyp package --target_arch=${{ matrix.arch }}
 
       - name: Upload artifacts
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
           name: macos-${{matrix.nodejs}}-${{matrix.arch}}
           path: build/stage/*/*.tar.gz
@@ -135,7 +135,7 @@ jobs:
               /pulsar-client-node/pkg/linux/build-napi-inside-docker.sh
 
       - name: Upload artifacts
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
           name: ${{matrix.image}}-${{matrix.nodejs}}-${{matrix.cpu.platform}}
           path: build/stage/*/*.tar.gz
@@ -205,7 +205,7 @@ jobs:
           npx node-pre-gyp package --target_arch=${{ env.TARGET }}
 
       - name: Upload artifacts
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
           name: windows-${{matrix.nodejs}}-${{matrix.arch}}
           path: build/stage/*/*.tar.gz

package/build-support/download-release-artifacts.py

@@ -17,8 +17,12 @@
 # specific language governing permissions and limitations
 # under the License.
 #
-
-import sys, json, urllib.request, os, shutil, zipfile, tempfile
+import sys
+import requests
+import os
+import shutil
+import zipfile
+import tempfile
 from pathlib import Path
 
 if len(sys.argv) != 3:
@@ -39,36 +43,35 @@ workflow_run_id = int(sys.argv[1])
 dest_path = sys.argv[2]
 
 workflow_run_url = LIST_URL % workflow_run_id
-request = urllib.request.Request(workflow_run_url,
-                    headers={'Accept': ACCEPT_HEADER, 'Authorization': 'Bearer ' + GITHUB_TOKEN})
-with urllib.request.urlopen(request) as response:
-    data = json.loads(response.read().decode("utf-8"))
-    for artifact in data['artifacts']:
-        name = artifact['name']
-        url = artifact['archive_download_url']
+headers = {'Accept': ACCEPT_HEADER, 'Authorization': f'Bearer {GITHUB_TOKEN}'}
 
-        print('Downloading %s from %s' % (name, url))
-        artifact_request = urllib.request.Request(url,
-                    headers={'Authorization': 'Bearer ' + GITHUB_TOKEN})
-        with urllib.request.urlopen(artifact_request) as response:
-            tmp_zip = tempfile.NamedTemporaryFile(delete=False)
-            try:
-                #
-                shutil.copyfileobj(response, tmp_zip)
-                tmp_zip.close()
+response = requests.get(workflow_run_url, headers=headers)
+response.raise_for_status()
 
-                dest_dir = os.path.join(dest_path, name)
-                Path(dest_dir).mkdir(parents=True, exist_ok=True)
-                with zipfile.ZipFile(tmp_zip.name, 'r') as z:
-                    z.extractall(dest_dir)
-            finally:
-                os.unlink(tmp_zip.name)
+data = response.json()
+for artifact in data['artifacts']:
+    name = artifact['name']
+    url = artifact['archive_download_url']
 
-    for root, dirs, files in os.walk(dest_path, topdown=False):
-        for name in files:
-            shutil.move(os.path.join(root, name), dest_path)
-        if not os.listdir(root):
-            os.rmdir(root)
+    print(f'Downloading {name} from {url}')
+    artifact_response = requests.get(url, headers=headers, stream=True)
+    artifact_response.raise_for_status()
 
+    with tempfile.NamedTemporaryFile(delete=False) as tmp_zip:
+        for chunk in artifact_response.iter_content(chunk_size=8192):
+            tmp_zip.write(chunk)
+        tmp_zip_path = tmp_zip.name
 
+    try:
+        dest_dir = os.path.join(dest_path, name)
+        Path(dest_dir).mkdir(parents=True, exist_ok=True)
+        with zipfile.ZipFile(tmp_zip_path, 'r') as z:
+            z.extractall(dest_dir)
+    finally:
+        os.unlink(tmp_zip_path)
 
+for root, dirs, files in os.walk(dest_path, topdown=False):
+    for name in files:
+        shutil.move(os.path.join(root, name), dest_path)
+    if not os.listdir(root):
+        os.rmdir(root)

package/build-support/stage-release.sh

@@ -20,7 +20,7 @@
 
 set -e -x
 
-if [ $# -neq 2 ]; then
+if [ "$#" -ne 2 ]; then
     echo "Usage: $0 \$DEST_PATH \$WORKFLOW_ID"
     exit 1
 fi

package/examples/consumer-schema.js

@@ -0,0 +1,66 @@
+/**
+ * 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('../');
+
+(async () => {
+  // Create a client
+  const client = new Pulsar.Client({
+    serviceUrl: 'pulsar://localhost:6650',
+    operationTimeoutSeconds: 30,
+  });
+
+  const schemaInfo = {
+    schemaType: "Json",
+    schema: JSON.stringify({
+      type: 'record',
+      name: 'Example',
+      namespace: 'test',
+      fields: [
+        {
+          name: 'a',
+          type: 'int',
+        },
+        {
+          name: 'b',
+          type: 'int',
+        },
+      ],
+    }),
+  };
+
+  // Create a consumer
+  const consumer = await client.subscribe({
+    topic: 'persistent://public/default/schema-test',
+    subscription: 'sub1',
+    subscriptionType: 'Shared',
+    ackTimeoutMs: 10000,
+    schema: schemaInfo,
+  });
+
+  // Receive messages
+  for (let i = 0; i < 10; i += 1) {
+    const msg = await consumer.receive();
+    console.log(msg.getData().toString());
+    consumer.acknowledge(msg);
+  }
+
+  await consumer.close();
+  await client.close();
+})();

package/examples/consummer_token_auth.js

@@ -0,0 +1,50 @@
+/**
+ * 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 { exit } = require('process');
+const Pulsar = require('../');
+console.log("Starting consumer");
+(async () => {
+
+  const auth = new Pulsar.AuthenticationToken({token: "eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJKb2UifQ.ipevRNuRP6HflG8cFKnmUPtypruRC4fb1DWtoLL62SY"});
+
+  // Create a client
+  const client = new Pulsar.Client({
+    serviceUrl: 'pulsar://localhost:6650',
+    authentication: auth,
+  });
+
+  // Create a consumer
+  const consumer = await client.subscribe({
+    topic: 'persistent://public/default/my-topic',
+    subscription: 'sub1',
+    subscriptionType: 'Shared',
+    ackTimeoutMs: 10000,
+  });
+
+  // Receive messages
+  for (let i = 0; i < 10; i += 1) {
+    const msg = await consumer.receive();
+    console.log(msg.getData().toString());
+    consumer.acknowledge(msg);
+  }
+
+  await consumer.close();
+  await client.close();
+})();

package/examples/consummer_token_auth_supplier.js

@@ -0,0 +1,56 @@
+/**
+ * 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 { exit } = require('process');
+const Pulsar = require('..');
+console.log("Starting consumer");
+
+async function getToken() {
+  console.log("Get token");
+  return "eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJKb2UifQ.ipevRNuRP6HflG8cFKnmUPtypruRC4fb1DWtoLL62SY";
+}
+
+(async () => {
+
+  const auth = new Pulsar.AuthenticationToken({token: getToken});
+
+  // Create a client
+  const client = new Pulsar.Client({
+    serviceUrl: 'pulsar://localhost:6650',
+    authentication: auth,
+  });
+
+  // Create a consumer
+  const consumer = await client.subscribe({
+    topic: 'persistent://public/default/my-topic',
+    subscription: 'sub1',
+    subscriptionType: 'Shared',
+    ackTimeoutMs: 10000,
+  });
+
+  // Receive messages
+  for (let i = 0; i < 10; i += 1) {
+    const msg = await consumer.receive();
+    console.log(msg.getData().toString());
+    consumer.acknowledge(msg);
+  }
+
+  await consumer.close();
+  await client.close();
+})();

package/examples/custom_logger.js

@@ -24,10 +24,10 @@ const Pulsar = require('..');
     const client = new Pulsar.Client({
         serviceUrl: 'pulsar://localhost:6650',
         operationTimeoutSeconds: 30,
-    });
-
-    Pulsar.Client.setLogHandler((level, file, line, message) => {
-        console.log('[%s][%s:%d] %s', Pulsar.LogLevel.toString(level), file, line, message);
+        log: (level, file, line, message) => {
+            console.log('[%s][%s:%d] %s', Pulsar.LogLevel.toString(level), file, line, message);
+        },
+        logLevel: Pulsar.LogLevel.DEBUG,
     });
 
     // Create a producer

package/examples/producer-schema.js

@@ -0,0 +1,76 @@
+/**
+ * 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('../');
+
+(async () => {
+
+  // Create a client
+  const client = new Pulsar.Client({
+    serviceUrl: 'pulsar://localhost:6650',
+    operationTimeoutSeconds: 30,
+  });
+
+  const schemaInfo = {
+    schemaType: "Json",
+    schema: JSON.stringify({
+      type: 'record',
+      name: 'Example',
+      namespace: 'test',
+      fields: [
+        {
+          name: 'a',
+          type: 'int',
+        },
+        {
+          name: 'b',
+          type: 'int',
+        },
+      ],
+    }),
+  };
+
+  const message = {
+    a: 1,
+    b: 2,
+  };
+
+// Create a producer
+  const producer = await client.createProducer({
+    topic: 'persistent://public/default/schema-test',
+    sendTimeoutMs: 30000,
+    batchingEnabled: true,
+    schema: schemaInfo,
+  });
+
+// Send messages
+  for (let i = 0; i < 100; i += 1) {
+    message.a = i;
+    message.b = i * 2;
+    const data = JSON.stringify(message);
+    producer.send({
+      data: Buffer.from(data),
+    });
+    console.log(`Sent message: ${data}`);
+  }
+  await producer.flush();
+
+  await producer.close();
+  await client.close();;
+})();

package/examples/producer_token_auth.js

@@ -0,0 +1,48 @@
+/**
+ * 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('../');
+
+(async () => {
+  const auth = new Pulsar.AuthenticationToken({token: "eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJKb2UifQ.ipevRNuRP6HflG8cFKnmUPtypruRC4fb1DWtoLL62SY"});
+
+  // Create a client
+  const client = new Pulsar.Client({
+    serviceUrl: 'pulsar://localhost:6650',
+    authentication: auth,
+  });
+
+  // Create a producer
+  const producer = await client.createProducer({
+    topic: 'persistent://public/default/my-topic',
+  });
+
+  // Send messages
+  for (let i = 0; i < 10; i += 1) {
+    const msg = `my-message-${i}`;
+    producer.send({
+      data: Buffer.from(msg),
+    });
+    console.log(`Sent message: ${msg}`);
+  }
+  await producer.flush();
+
+  await producer.close();
+  await client.close();
+})();

package/examples/producer_token_auth_supplier.js

@@ -0,0 +1,53 @@
+/**
+ * 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('..');
+
+async function getToken() {
+  console.log("Get token");
+  return "eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJKb2UifQ.ipevRNuRP6HflG8cFKnmUPtypruRC4fb1DWtoLL62SY";
+}
+
+(async () => {
+  const auth = new Pulsar.AuthenticationToken({token: getToken});
+
+  // Create a client
+  const client = new Pulsar.Client({
+    serviceUrl: 'pulsar://localhost:6650',
+    authentication: auth,
+  });
+
+  // Create a producer
+  const producer = await client.createProducer({
+    topic: 'persistent://public/default/my-topic',
+  });
+
+  // Send messages
+  for (let i = 0; i < 10; i += 1) {
+    const msg = `my-message-${i}`;
+    producer.send({
+      data: Buffer.from(msg),
+    });
+    console.log(`Sent message: ${msg}`);
+  }
+  await producer.flush();
+
+  await producer.close();
+  await client.close();
+})();

package/index.d.ts

@@ -32,6 +32,7 @@ export interface ClientConfig {
   statsIntervalInSeconds?: number;
   listenerName?: string;
   log?: (level: LogLevel, file: string, line: number, message: string) => void;
+  logLevel?: LogLevel;
 }
 
 export class Client {
@@ -224,7 +225,7 @@ export class AthenzX509Config {
 }
 
 export class AuthenticationToken {
-  constructor(params: { token: string });
+  constructor(params: { token: string | (() => string) | (() => Promise<string>) });
 }
 
 export class AuthenticationOauth2 {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pulsar-client",
-  "version": "1.12.0",
+  "version": "1.13.0-rc.3",
   "description": "Pulsar Node.js client",
   "main": "index.js",
   "types": "index.d.ts",

package/pulsar-client-cpp.txt

@@ -1,2 +1,2 @@
-CPP_CLIENT_BASE_URL=https://archive.apache.org/dist/pulsar/pulsar-client-cpp-3.6.0
-CPP_CLIENT_VERSION=3.6.0
+CPP_CLIENT_BASE_URL=https://archive.apache.org/dist/pulsar/pulsar-client-cpp-3.7.0
+CPP_CLIENT_VERSION=3.7.0

package/src/Authentication.cc

@@ -18,6 +18,7 @@
  */
 
 #include "Authentication.h"
+#include <future>
 
 static const std::string PARAM_TLS_CERT = "certificatePath";
 static const std::string PARAM_TLS_KEY = "privateKeyPath";
@@ -25,6 +26,62 @@ static const std::string PARAM_TOKEN = "token";
 static const std::string PARAM_USERNAME = "username";
 static const std::string PARAM_PASSWORD = "password";
 
+void FinalizeTokenSupplierCallback(Napi::Env env, TokenSupplierCallback *cb, void *) { delete cb; }
+
+struct TokenSupplierProxyData {
+  std::function<void(void)> callback;
+  std::string token;
+
+  TokenSupplierProxyData(std::function<void(void)> callback) : callback(callback), token(std::string()) {}
+};
+
+void TokenSupplierProxy(Napi::Env env, Napi::Function jsCallback, TokenSupplierProxyData *data) {
+  Napi::Value ret = jsCallback.Call({});
+  if (ret.IsPromise()) {
+    Napi::Promise promise = ret.As<Napi::Promise>();
+    Napi::Value thenValue = promise.Get("then");
+    if (thenValue.IsFunction()) {
+      Napi::Function then = thenValue.As<Napi::Function>();
+      Napi::Function callback = Napi::Function::New(env, [data](const Napi::CallbackInfo &info) {
+        Napi::Value value = info[0];
+        if (value.IsString()) {
+          data->token = value.ToString().Utf8Value();
+        }
+        data->callback();
+      });
+      then.Call(promise, {callback});
+      return;
+    }
+  }
+  if (ret.IsString()) {
+    data->token = ret.ToString().Utf8Value();
+  }
+  data->callback();
+}
+
+char *TokenSupplier(void *ctx) {
+  TokenSupplierCallback *tokenSupplierCallback = (TokenSupplierCallback *)ctx;
+  if (tokenSupplierCallback->callback.Acquire() != napi_ok) {
+    char *empty = (char *)malloc(0);
+    return empty;
+  }
+
+  std::promise<void> promise;
+  std::future<void> future = promise.get_future();
+
+  std::unique_ptr<TokenSupplierProxyData> dataPtr(
+      new TokenSupplierProxyData([&promise]() { promise.set_value(); }));
+
+  tokenSupplierCallback->callback.BlockingCall(dataPtr.get(), TokenSupplierProxy);
+  tokenSupplierCallback->callback.Release();
+
+  future.wait();
+
+  char *token = (char *)malloc(dataPtr->token.size());
+  strcpy(token, dataPtr->token.c_str());
+  return token;
+}
+
 Napi::FunctionReference Authentication::constructor;
 
 Napi::Object Authentication::Init(Napi::Env env, Napi::Object exports) {
@@ -69,12 +126,28 @@ Authentication::Authentication(const Napi::CallbackInfo &info)
           pulsar_authentication_tls_create(obj.Get(PARAM_TLS_CERT).ToString().Utf8Value().c_str(),
                                            obj.Get(PARAM_TLS_KEY).ToString().Utf8Value().c_str());
     } else if (authMethod == "token") {
-      if (!obj.Has(PARAM_TOKEN) || !obj.Get(PARAM_TOKEN).IsString()) {
-        Napi::Error::New(env, "Missing required parameter").ThrowAsJavaScriptException();
-        return;
+      if (obj.Has(PARAM_TOKEN)) {
+        if (obj.Get(PARAM_TOKEN).IsString()) {
+          this->cAuthentication =
+              pulsar_authentication_token_create(obj.Get(PARAM_TOKEN).ToString().Utf8Value().c_str());
+          return;
+        }
+
+        if (obj.Get(PARAM_TOKEN).IsFunction()) {
+          this->tokenSupplier = new TokenSupplierCallback();
+          Napi::ThreadSafeFunction callback = Napi::ThreadSafeFunction::New(
+              obj.Env(), obj.Get(PARAM_TOKEN).As<Napi::Function>(), "Token Supplier Callback", 1, 1,
+              (void *)NULL, FinalizeTokenSupplierCallback, this->tokenSupplier);
+          this->tokenSupplier->callback = std::move(callback);
+
+          this->cAuthentication =
+              pulsar_authentication_token_create_with_supplier(&TokenSupplier, this->tokenSupplier);
+          return;
+        }
       }
-      this->cAuthentication =
-          pulsar_authentication_token_create(obj.Get(PARAM_TOKEN).ToString().Utf8Value().c_str());
+
+      Napi::Error::New(env, "Missing required parameter").ThrowAsJavaScriptException();
+      return;
     } else if (authMethod == "basic") {
       if (!obj.Has(PARAM_USERNAME) || !obj.Get(PARAM_USERNAME).IsString() || !obj.Has(PARAM_PASSWORD) ||
           !obj.Get(PARAM_PASSWORD).IsString()) {
@@ -105,6 +178,9 @@ Authentication::Authentication(const Napi::CallbackInfo &info)
 }
 
 Authentication::~Authentication() {
+  if (this->tokenSupplier != nullptr) {
+    this->tokenSupplier->callback.Release();
+  }
   if (this->cAuthentication != nullptr) {
     pulsar_authentication_free(this->cAuthentication);
   }

package/src/Authentication.h

@@ -22,6 +22,7 @@
 
 #include <napi.h>
 #include <pulsar/c/authentication.h>
+#include "TokenSupplier.h"
 
 class Authentication : public Napi::ObjectWrap<Authentication> {
  public:
@@ -33,6 +34,8 @@ class Authentication : public Napi::ObjectWrap<Authentication> {
  private:
   static Napi::FunctionReference constructor;
   pulsar_authentication_t *cAuthentication;
+
+  TokenSupplierCallback *tokenSupplier;
 };
 
 #endif

package/src/Client.cc

@@ -40,6 +40,7 @@ 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";
+static const std::string CFG_LOG_LEVEL = "logLevel";
 static const std::string CFG_LISTENER_NAME = "listenerName";
 
 LogCallback *Client::logCallback = nullptr;
@@ -107,7 +108,18 @@ Client::Client(const Napi::CallbackInfo &info) : Napi::ObjectWrap<Client>(info)
                                                                        pulsar_client_configuration_free);
 
   // The logger can only be set once per process, so we will take control of it
-  pulsar_client_configuration_set_logger(cClientConfig.get(), &LogMessage, nullptr);
+  if (clientConfig.Has(CFG_LOG_LEVEL) && clientConfig.Get(CFG_LOG_LEVEL).IsNumber()) {
+    int32_t logLevelInt = clientConfig.Get(CFG_LOG_LEVEL).ToNumber().Int32Value();
+    this->logLevel = static_cast<pulsar_logger_level_t>(logLevelInt);
+  }
+  pulsar_logger_t logger;
+  logger.ctx = &this->logLevel;
+  logger.is_enabled = [](pulsar_logger_level_t level, void *ctx) {
+    auto *logLevel = static_cast<pulsar_logger_level_t *>(ctx);
+    return level >= *logLevel;
+  };
+  logger.log = &LogMessage;
+  pulsar_client_configuration_set_logger_t(cClientConfig.get(), logger);
 
   // log config option should be deprecated in favour of static setLogHandler method
   if (clientConfig.Has(CFG_LOG) && clientConfig.Get(CFG_LOG).IsFunction()) {

package/src/Client.h

@@ -53,6 +53,7 @@ class Client : public Napi::ObjectWrap<Client> {
   static Napi::FunctionReference constructor;
   std::shared_ptr<pulsar_client_t> cClient;
   std::shared_ptr<pulsar_client_configuration_t> cClientConfig;
+  pulsar_logger_level_t logLevel = pulsar_logger_level_t::pulsar_INFO;
 
   Napi::Value CreateProducer(const Napi::CallbackInfo &info);
   Napi::Value Subscribe(const Napi::CallbackInfo &info);

package/src/Consumer.cc

@@ -77,32 +77,28 @@ void MessageListenerProxy(Napi::Env env, Napi::Function jsCallback, MessageListe
   Napi::Object msg = Message::NewInstance({}, data->cMessage);
   Consumer *consumer = data->consumer;
 
-  // `consumer` might be null in certain cases, segmentation fault might happend without this null check. We
-  // need to handle this rare case in future.
-  if (consumer) {
-    Napi::Value ret;
-    try {
-      ret = jsCallback.Call({msg, consumer->Value()});
-    } catch (std::exception &exception) {
-      logMessageListenerError(consumer, exception.what());
-    }
+  Napi::Value ret;
+  try {
+    ret = jsCallback.Call({msg, consumer->Value()});
+  } catch (std::exception &exception) {
+    logMessageListenerError(consumer, exception.what());
+  }
 
-    if (ret.IsPromise()) {
-      Napi::Promise promise = ret.As<Napi::Promise>();
-      Napi::Function catchFunc = promise.Get("catch").As<Napi::Function>();
+  if (ret.IsPromise()) {
+    Napi::Promise promise = ret.As<Napi::Promise>();
+    Napi::Function catchFunc = promise.Get("catch").As<Napi::Function>();
 
-      ret = catchFunc.Call(promise, {Napi::Function::New(env, [consumer](const Napi::CallbackInfo &info) {
-                             Napi::Error error = info[0].As<Napi::Error>();
-                             logMessageListenerError(consumer, error.what());
-                           })});
+    ret = catchFunc.Call(promise, {Napi::Function::New(env, [consumer](const Napi::CallbackInfo &info) {
+                           Napi::Error error = info[0].As<Napi::Error>();
+                           logMessageListenerError(consumer, error.what());
+                         })});
 
-      promise = ret.As<Napi::Promise>();
-      Napi::Function finallyFunc = promise.Get("finally").As<Napi::Function>();
+    promise = ret.As<Napi::Promise>();
+    Napi::Function finallyFunc = promise.Get("finally").As<Napi::Function>();
 
-      finallyFunc.Call(
-          promise, {Napi::Function::New(env, [data](const Napi::CallbackInfo &info) { data->callback(); })});
-      return;
-    }
+    finallyFunc.Call(
+        promise, {Napi::Function::New(env, [data](const Napi::CallbackInfo &info) { data->callback(); })});
+    return;
   }
   data->callback();
 }
@@ -111,7 +107,7 @@ void MessageListener(pulsar_consumer_t *rawConsumer, pulsar_message_t *rawMessag
   std::shared_ptr<pulsar_message_t> cMessage(rawMessage, pulsar_message_free);
   MessageListenerCallback *listenerCallback = (MessageListenerCallback *)ctx;
 
-  Consumer *consumer = (Consumer *)listenerCallback->consumer;
+  Consumer *consumer = static_cast<Consumer *>(listenerCallback->consumerFuture.get());
 
   if (listenerCallback->callback.Acquire() != napi_ok) {
     return;
@@ -135,7 +131,7 @@ void Consumer::SetListenerCallback(MessageListenerCallback *listener) {
   }
 
   if (listener != nullptr) {
-    listener->consumer = this;
+    listener->consumerPromise.set_value(this);
     // If a consumer listener is set, the Consumer instance is kept alive even if it goes out of scope in JS
     // code.
     this->Ref();
@@ -168,11 +164,6 @@ struct ConsumerNewInstanceContext {
     auto cConsumer = std::shared_ptr<pulsar_consumer_t>(rawConsumer, pulsar_consumer_free);
     auto listener = consumerConfig->GetListenerCallback();
 
-    if (listener) {
-      // pause, will resume in OnOK, to prevent MessageListener get a nullptr of consumer
-      pulsar_consumer_pause_message_listener(cConsumer.get());
-    }
-
     deferred->Resolve([cConsumer, consumerConfig, listener](const Napi::Env env) {
       Napi::Object obj = Consumer::constructor.New({});
       Consumer *consumer = Consumer::Unwrap(obj);
@@ -180,11 +171,6 @@ struct ConsumerNewInstanceContext {
       consumer->SetCConsumer(cConsumer);
       consumer->SetListenerCallback(listener);
 
-      if (listener) {
-        // resume to enable MessageListener function callback
-        resume_message_listener(cConsumer.get());
-      }
-
       return obj;
     });
   }

package/src/MessageListener.h

@@ -21,14 +21,16 @@
 #define MESSAGELISTENER_H
 
 #include <napi.h>
+#include <future>
 
 struct MessageListenerCallback {
   Napi::ThreadSafeFunction callback;
 
-  // Using consumer as void* since the ListenerCallback is shared between Config and Consumer.
-  void *consumer;
+  // Use future store consumer point, because need ensure sync.
+  std::promise<void *> consumerPromise;
+  std::shared_future<void *> consumerFuture;
 
-  MessageListenerCallback() : consumer(nullptr) {}
+  MessageListenerCallback() : consumerPromise(), consumerFuture(consumerPromise.get_future()) {}
 };
 
 #endif

package/src/TokenSupplier.h

@@ -0,0 +1,31 @@
+/**
+ * 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 PULSAR_CLIENT_NODE_TOKENSUPPLIER_H
+#define PULSAR_CLIENT_NODE_TOKENSUPPLIER_H
+
+#include <napi.h>
+
+struct TokenSupplierCallback {
+  Napi::ThreadSafeFunction callback;
+
+  TokenSupplierCallback() {}
+};
+
+#endif  // PULSAR_CLIENT_NODE_TOKENSUPPLIER_H

package/tests/end_to_end.test.js

@@ -1284,5 +1284,49 @@ const Pulsar = require('../index');
       await consumer.close();
       await client.close();
     });
+
+    test('AuthenticationToken token supplier', async () => {
+      const mockTokenSupplier = jest.fn().mockReturnValue('token');
+      const auth = new Pulsar.AuthenticationToken({
+        token: mockTokenSupplier,
+      });
+      const client = new Pulsar.Client({
+        serviceUrl: 'pulsar://localhost:6650',
+        authentication: auth,
+      });
+
+      // A producer/consumer is needed to triger the callback function
+      const topic = 'persistent://public/default/token-auth';
+      const producer = await client.createProducer({
+        topic,
+      });
+      expect(producer).not.toBeNull();
+      expect(mockTokenSupplier).toHaveBeenCalledTimes(1);
+
+      await producer.close();
+      await client.close();
+    });
+
+    test('AuthenticationToken async token supplier', async () => {
+      const mockTokenSupplier = jest.fn().mockResolvedValue('token');
+      const auth = new Pulsar.AuthenticationToken({
+        token: mockTokenSupplier,
+      });
+      const client = new Pulsar.Client({
+        serviceUrl: 'pulsar://localhost:6650',
+        authentication: auth,
+      });
+
+      // A producer/consumer is needed to triger the callback function
+      const topic = 'persistent://public/default/token-auth';
+      const producer = await client.createProducer({
+        topic,
+      });
+      expect(producer).not.toBeNull();
+      expect(mockTokenSupplier).toHaveBeenCalledTimes(1);
+
+      await producer.close();
+      await client.close();
+    });
   });
 })();

package/tstest.ts

@@ -67,7 +67,9 @@ import Pulsar = require('./index');
   });
 
   const authToken: Pulsar.AuthenticationToken = new Pulsar.AuthenticationToken({
-    token: 'foobar',
+    token: async () => {
+      return 'foobar';
+    },
   });
 
   const authBasic: Pulsar.AuthenticationBasic = new Pulsar.AuthenticationBasic({

package/cmake-build-debug/CMakeFiles/clion-Debug-log.txt

@@ -1 +0,0 @@
-CMakeLists.txt not found in /Users/shibaodi/CLionProjects/pulsar-client-node Select CMakeLists.txt