ADD: Add configurable logging to C++ client

Author: threecgreen

CHANGELOG.md

@@ -6,6 +6,7 @@
 - Added `strike_price`, `strike_price_currency`, and `instrument_class` to `InstrumentDefMsg`
 - Renamed `BatchJob.cost` to `cost_usd` and value now expressed as US dollars
 - Added `FixedPx` helper class for formatting fixed prices
+- Added configurable log receiver `ILogReceiver`
 - Added `instrument_class`, `strike_price`, and `strike_price_currency` to definition schema
 - Added additional `condition` variants for `DatasetConditionDetail` (degraded, pending, missing)
 - Added additional member `last_modified_date` to `DatasetConditionDetail` Added `has_mixed_schema`, `has_mixed_stype_in`, and `ts_out` to `Metadata` to support live data

cmake/SourcesAndHeaders.cmake

@@ -14,6 +14,7 @@ set(headers
   include/databento/live.hpp
   include/databento/live_blocking.hpp
   include/databento/live_threaded.hpp
+  include/databento/log.hpp
   include/databento/metadata.hpp
   include/databento/record.hpp
   include/databento/symbology.hpp
@@ -42,6 +43,7 @@ set(sources
   src/live.cpp
   src/live_blocking.cpp
   src/live_threaded.cpp
+  src/log.cpp
   src/metadata.cpp
   src/record.cpp
   src/symbology.cpp

example/live/simple.cpp

@@ -1,26 +1,30 @@
 #include <csignal>  // sig_atomic_t
 #include <cstdint>
 #include <iostream>
+#include <memory>
 #include <unordered_map>
 
 #include "databento/constants.hpp"
 #include "databento/dbn.hpp"
 #include "databento/enums.hpp"
 #include "databento/live.hpp"
 #include "databento/live_threaded.hpp"
+#include "databento/log.hpp"
 #include "databento/record.hpp"
 #include "databento/with_ts_out.hpp"
 
 static std::sig_atomic_t volatile gSignal;
 
 int main() {
   std::unordered_map<std::uint32_t, std::string> symbol_mappings;
+  std::unique_ptr<databento::ILogReceiver> log_receiver{
+      new databento::ConsoleLogReceiver{databento::LogLevel::Debug}};
 
   auto client = databento::LiveBuilder{}
+                    .SetLogReceiver(log_receiver.get())
                     .SetKeyFromEnv()
                     .SetDataset(databento::dataset::kGlbxMdp3)
                     .BuildThreaded();
-  std::cout << "Authenticated successfully\n";
 
   // Set up signal handler for Ctrl+C
   std::signal(SIGINT, [](int signal) { gSignal = signal; });

include/databento/flag_set.hpp

@@ -32,18 +32,20 @@ class FlagSet {
       std::uint8_t repr)
       : repr_{repr} {}
 
-  constexpr FlagSet operator~() const { return FlagSet(~repr_); }
+  constexpr FlagSet operator~() const {
+    return FlagSet{static_cast<Repr>(~repr_)};
+  }
 
   constexpr FlagSet operator|(FlagSet rhs) const {
-    return FlagSet(repr_ | rhs.repr_);
+    return FlagSet{static_cast<Repr>(repr_ | rhs.repr_)};
   }
 
   constexpr FlagSet operator&(FlagSet rhs) const {
-    return FlagSet(repr_ & rhs.repr_);
+    return FlagSet{static_cast<Repr>(repr_ & rhs.repr_)};
   }
 
   constexpr FlagSet operator^(FlagSet rhs) const {
-    return FlagSet(repr_ ^ rhs.repr_);
+    return FlagSet{static_cast<Repr>(repr_ ^ rhs.repr_)};
   }
 
   FlagSet operator|=(FlagSet rhs) {

include/databento/live.hpp

@@ -6,6 +6,8 @@
 #include "databento/live_threaded.hpp"
 
 namespace databento {
+class ILogReceiver;
+
 // A helper class for constructing a Live client, either an instance of
 // LiveBlocking or LiveThreaded.
 class LiveBuilder {
@@ -21,6 +23,8 @@ class LiveBuilder {
   LiveBuilder& SetDataset(std::string dataset);
   // Whether to append the gateway send timestamp after each DBN message.
   LiveBuilder& SetSendTsOut(bool send_ts_out);
+  // Sets the receiver of the logs to be used by the client.
+  LiveBuilder& SetLogReceiver(ILogReceiver* log_receiver);
   // Attempts to construct an instance of a blocking live client or throws an
   // exception.
   LiveBlocking BuildBlocking();
@@ -29,8 +33,9 @@ class LiveBuilder {
   LiveThreaded BuildThreaded();
 
  private:
-  void Validate() const;
+  void Validate();
 
+  ILogReceiver* log_receiver_{};
   std::string key_;
   std::string dataset_;
   bool send_ts_out_{true};

include/databento/live_blocking.hpp

@@ -14,15 +14,18 @@
 #include "databento/record.hpp"             // Record
 
 namespace databento {
+class ILogReceiver;
+
 // A client for interfacing with Databento's real-time and intraday replay
 // market data API. This client provides a blocking API for getting the next
 // record. Unlike Historical, each instance of LiveBlocking is associated with a
 // particular dataset.
 class LiveBlocking {
  public:
-  LiveBlocking(std::string key, std::string dataset, bool send_ts_out);
-  LiveBlocking(std::string key, std::string dataset, std::string gateway,
-               std::uint16_t port, bool send_ts_out);
+  LiveBlocking(ILogReceiver* log_receiver, std::string key, std::string dataset,
+               bool send_ts_out);
+  LiveBlocking(ILogReceiver* log_receiver, std::string key, std::string dataset,
+               std::string gateway, std::uint16_t port, bool send_ts_out);
   /*
    * Getters
    */
@@ -65,16 +68,17 @@ class LiveBlocking {
 
  private:
   std::string DetermineGateway() const;
-  std::string Authenticate();
+  std::uint64_t Authenticate();
   std::string DecodeChallenge();
   std::string GenerateCramReply(const std::string& challenge_key);
   std::string EncodeAuthReq(const std::string& auth);
-  void DecodeAuthResp();
+  std::uint64_t DecodeAuthResp();
   detail::TcpClient::Result FillBuffer(std::chrono::milliseconds timeout);
   RecordHeader* BufferRecordHeader();
 
   static constexpr std::size_t kMaxStrLen = 24L * 1024;
 
+  ILogReceiver* log_receiver_;
   std::string key_;
   std::string dataset_;
   std::string gateway_;
@@ -83,7 +87,7 @@ class LiveBlocking {
   std::array<char, kMaxStrLen> buffer_{};
   std::size_t buffer_size_{};
   std::size_t buffer_idx_{};
-  std::string session_id_;
+  std::uint64_t session_id_;
   Record current_record_{nullptr};
 };
 }  // namespace databento

include/databento/live_threaded.hpp

@@ -13,15 +13,18 @@
 #include "databento/timeseries.hpp"  // MetadataCallback, RecordCallback
 
 namespace databento {
+class ILogReceiver;
+
 // A client for interfacing with Databento's real-time and intraday replay
 // market data API. This client provides a threaded event-driven API for
 // receiving the next record. Unlike Historical, each instance of LiveThreaded
 // is associated with a particular dataset.
 class LiveThreaded {
  public:
-  LiveThreaded(std::string key, std::string dataset, bool send_ts_out);
-  LiveThreaded(std::string key, std::string dataset, std::string gateway,
-               std::uint16_t port, bool send_ts_out);
+  LiveThreaded(ILogReceiver* log_receiver, std::string key, std::string dataset,
+               bool send_ts_out);
+  LiveThreaded(ILogReceiver* log_receiver, std::string key, std::string dataset,
+               std::string gateway, std::uint16_t port, bool send_ts_out);
   LiveThreaded(const LiveThreaded&) = delete;
   LiveThreaded& operator=(const LiveThreaded&) = delete;
   LiveThreaded(LiveThreaded&& other) noexcept;

include/databento/log.hpp

@@ -0,0 +1,42 @@
+#pragma once
+
+#include <cstdint>
+#include <iosfwd>  // ostream
+#include <string>
+
+namespace databento {
+enum class LogLevel : std::uint8_t {
+  Debug,
+  Info,
+  Warning,
+  Error,
+};
+
+class ILogReceiver {
+ public:
+  static ILogReceiver* Default();
+
+  virtual ~ILogReceiver() = default;
+
+  virtual void Receive(databento::LogLevel level, const std::string& msg) = 0;
+};
+
+class NullLogReceiver : public ILogReceiver {
+ public:
+  void Receive(databento::LogLevel, const std::string&) override {}
+};
+
+class ConsoleLogReceiver : public ILogReceiver {
+ public:
+  ConsoleLogReceiver();
+  explicit ConsoleLogReceiver(LogLevel min_level);
+  explicit ConsoleLogReceiver(std::ostream& stream);
+  ConsoleLogReceiver(LogLevel min_level, std::ostream& stream);
+
+  void Receive(LogLevel level, const std::string& msg) override;
+
+ private:
+  std::ostream& stream_;
+  const databento::LogLevel min_level_;
+};
+}  // namespace databento

src/live.cpp

@@ -6,6 +6,7 @@
 #include "databento/exceptions.hpp"     // InvalidArgumentError, LiveApiError
 #include "databento/live_blocking.hpp"  // LiveBlocking
 #include "databento/live_threaded.hpp"  // LiveThreaded
+#include "databento/log.hpp"
 
 using databento::LiveBuilder;
 
@@ -38,21 +39,30 @@ LiveBuilder& LiveBuilder::SetSendTsOut(bool send_ts_out) {
   return *this;
 }
 
+LiveBuilder& LiveBuilder::SetLogReceiver(
+    databento::ILogReceiver* log_receiver) {
+  log_receiver_ = log_receiver;
+  return *this;
+}
+
 databento::LiveBlocking LiveBuilder::BuildBlocking() {
   Validate();
-  return databento::LiveBlocking{key_, dataset_, send_ts_out_};
+  return databento::LiveBlocking{log_receiver_, key_, dataset_, send_ts_out_};
 }
 
 databento::LiveThreaded LiveBuilder::BuildThreaded() {
   Validate();
-  return databento::LiveThreaded{key_, dataset_, send_ts_out_};
+  return databento::LiveThreaded{log_receiver_, key_, dataset_, send_ts_out_};
 }
 
-void LiveBuilder::Validate() const {
+void LiveBuilder::Validate() {
   if (key_.empty()) {
     throw Exception{"'key' is unset"};
   }
   if (dataset_.empty()) {
     throw Exception{"'dataset' is unset"};
   }
+  if (log_receiver_ == nullptr) {
+    log_receiver_ = databento::ILogReceiver::Default();
+  }
 }