Add silent_logging option to silence the c++ logger

Author: rwstauner

ext/bindings/client.cpp

@@ -4,6 +4,7 @@
 #include <ruby/thread.h>
 
 #include "client.hpp"
+#include "logger.hpp"
 #include "util.hpp"
 
 namespace pulsar_rb {
@@ -55,6 +56,25 @@ void ClientConfiguration::setLogConfFilePath(const std::string& path) {
   _config.setLogConfFilePath(path);
 }
 
+void ClientConfiguration::setSilentLogging(bool enable) {
+  // The logger can only be set once, so if it's already on we cannot disable it.
+  if (silentLogging) {
+    if (!enable) {
+      throw Rice::Exception(rb_eArgError, "silent_logging can only be set once");
+    }
+  }
+
+  if (enable) {
+    silentLogging = true;
+    std::unique_ptr<LoggerFactory> loggerFactory = SilentLoggerFactory::create();
+    _config.setLogger(loggerFactory.release());
+  }
+}
+
+bool ClientConfiguration::getSilentLogging() {
+  return silentLogging;
+}
+
 bool ClientConfiguration::isUseTls() {
   return _config.isUseTls();
 }
@@ -175,6 +195,8 @@ void bind_client(Module& module) {
     .define_method("concurrent_lookup_requests=", &pulsar_rb::ClientConfiguration::setConcurrentLookupRequest)
     .define_method("log_conf_file_path", &pulsar_rb::ClientConfiguration::getLogConfFilePath)
     .define_method("log_conf_file_path=", &pulsar_rb::ClientConfiguration::setLogConfFilePath)
+    .define_method("silent_logging?", &pulsar_rb::ClientConfiguration::getSilentLogging)
+    .define_method("silent_logging=", &pulsar_rb::ClientConfiguration::setSilentLogging)
     .define_method("use_tls?", &pulsar_rb::ClientConfiguration::isUseTls)
     .define_method("use_tls=", &pulsar_rb::ClientConfiguration::setUseTls)
     .define_method("tls_trust_certs_file_path", &pulsar_rb::ClientConfiguration::getTlsTrustCertsFilePath)

ext/bindings/client.hpp

@@ -13,6 +13,7 @@ namespace pulsar_rb {
   class ClientConfiguration {
   public:
     pulsar::ClientConfiguration _config;
+    bool silentLogging = false;
     ClientConfiguration();
 
     void setAuthFromToken(const std::string &token);
@@ -26,6 +27,8 @@ namespace pulsar_rb {
     void setConcurrentLookupRequest(int n);
     std::string getLogConfFilePath();
     void setLogConfFilePath(const std::string& path);
+    void setSilentLogging(bool);
+    bool getSilentLogging();
     bool isUseTls();
     void setUseTls(bool enable);
     std::string getTlsTrustCertsFilePath();

ext/bindings/logger.cpp

@@ -0,0 +1,23 @@
+#include <pulsar/Logger.h>
+
+#include "logger.hpp"
+
+namespace pulsar_rb {
+
+class SilentLogger : public pulsar::Logger {
+  std::string _logger;
+
+  public:
+    SilentLogger(const std::string &logger) : _logger(logger) {}
+
+    bool isEnabled(Level level) { return false; }
+    void log(Level level, int line, const std::string &message) { }
+};
+
+pulsar::Logger *SilentLoggerFactory::getLogger(const std::string& file) { return new SilentLogger(file); }
+
+std::unique_ptr<pulsar::LoggerFactory> SilentLoggerFactory::create() {
+  return std::unique_ptr<pulsar::LoggerFactory>(new SilentLoggerFactory());
+}
+
+}

ext/bindings/logger.hpp

@@ -0,0 +1,17 @@
+#ifndef __PULSAR_RUBY_CLIENT_LOGGER_HPP
+#define __PULSAR_RUBY_CLIENT_LOGGER_HPP
+
+#include <pulsar/Logger.h>
+
+namespace pulsar_rb {
+
+class SilentLoggerFactory : public pulsar::LoggerFactory {
+  public:
+    pulsar::Logger* getLogger(const std::string& fileName);
+
+    static std::unique_ptr<pulsar::LoggerFactory> create();
+};
+
+}
+
+#endif

lib/pulsar/client_configuration.rb

@@ -134,6 +134,7 @@ def populate(config={})
       populate_one(config, :message_listener_threads)
       populate_one(config, :concurrent_lookup_requests)
       populate_one(config, :log_conf_file_path)
+      populate_one(config, :silent_logging)
       populate_one(config, :use_tls)
       populate_one(config, :tls_trust_certs_file_path)
       populate_one(config, :tls_allow_insecure_connection)

spec/pulsar/client_configuration_spec.rb

@@ -168,6 +168,22 @@
       test_config.unlink
     end
   end
+
+  describe "silent logging" do
+    it "is off by default" do
+      expect(Pulsar::ClientConfiguration.new.silent_logging?).to eq(false)
+    end
+
+    it "can be enabled" do
+      expect(Pulsar::ClientConfiguration.from({silent_logging: true}).silent_logging?).to eq(true)
+    end
+
+    it "raises when set twice" do
+      expect {
+        Pulsar::ClientConfiguration.from({silent_logging: true}).silent_logging = false
+      }.to raise_error(ArgumentError, /silent_logging can only be set once/)
+    end
+  end
 end
 
 def create_temp_config(content)