asherah 1.3.27 → 1.3.28

package/src/cobhan.h

@@ -35,11 +35,8 @@ calculate_cobhan_buffer_allocation_size(size_t data_len_bytes) {
 }
 
 __attribute__((always_inline)) inline void
-configure_cbuffer(char *cobhan_buffer, size_t length) {
-  if (unlikely(verbose_flag)) {
-    debug_log(__func__, "configure_cbuffer(" + format_ptr(cobhan_buffer) +
-                            ", " + std::to_string(length) + ")");
-  }
+configure_cbuffer(Logger &logger, char *cobhan_buffer, size_t length) {
+  logger.debug_log_configure_cbuffer(__func__, cobhan_buffer, length);
 
   *((int32_t *)cobhan_buffer) = length;
   // Reserved for future use
@@ -61,12 +58,13 @@ get_canary_ptr(char *cobhan_buffer) {
   return cbuffer_data_ptr(cobhan_buffer) + cobhan_buffer_size_bytes + 1;
 }
 
-__attribute__((always_inline)) inline bool check_canary_ptr(char *canary_ptr) {
+__attribute__((always_inline)) inline bool check_canary_ptr(Logger &logger,
+                                                            char *canary_ptr) {
   int32_t zero_value = *((int32_t *)(canary_ptr));
   if (zero_value != 0) {
     std::string error_msg =
         "Canary check failed: " + std::to_string(zero_value) + " != 0";
-    error_log(__func__, error_msg);
+    logger.error_log(__func__, error_msg);
     return false;
   }
   int32_t canary_value = *((int32_t *)(canary_ptr + sizeof(int32_t)));
@@ -74,61 +72,61 @@ __attribute__((always_inline)) inline bool check_canary_ptr(char *canary_ptr) {
     std::string error_msg =
         "Canary check failed: " + std::to_string(canary_value) +
         " != " + std::to_string(canary_constant);
-    error_log(__func__, error_msg);
+    logger.error_log(__func__, error_msg);
     return false;
   }
   return true;
 }
 
 __attribute__((always_inline)) inline std::unique_ptr<char[]>
-heap_allocate_cbuffer(const char *variable_name, size_t size_bytes) {
+heap_allocate_cbuffer(Logger &logger, const char *variable_name,
+                      size_t size_bytes) {
   size_t cobhan_buffer_allocation_size =
       calculate_cobhan_buffer_allocation_size(size_bytes);
 
-  if (unlikely(verbose_flag)) {
-    debug_log_new(__func__, variable_name, cobhan_buffer_allocation_size);
-  }
+  logger.debug_log_new(__func__, variable_name, cobhan_buffer_allocation_size);
 
   char *cobhan_buffer = new (std::nothrow) char[cobhan_buffer_allocation_size];
   if (unlikely(cobhan_buffer == nullptr)) {
     std::string error_msg = "new[" +
                             std::to_string(cobhan_buffer_allocation_size) +
                             "] returned null";
-    error_log(__func__, error_msg);
+    logger.error_log(__func__, error_msg);
     return nullptr;
   }
   std::unique_ptr<char[]> cobhan_buffer_unique_ptr(cobhan_buffer);
-  configure_cbuffer(cobhan_buffer, size_bytes + safety_padding_bytes);
+  configure_cbuffer(logger, cobhan_buffer, size_bytes + safety_padding_bytes);
   return cobhan_buffer_unique_ptr;
 }
 
-#define ALLOCATE_CBUFFER_UNIQUE_PTR(cobhan_buffer, buffer_size, unique_ptr,    \
-                                    max_stack_alloc_size, function_name)       \
+#define ALLOCATE_CBUFFER_UNIQUE_PTR(logger, cobhan_buffer, buffer_size,        \
+                                    unique_ptr, max_stack_alloc_size,          \
+                                    function_name)                             \
   do {                                                                         \
     if (buffer_size < max_stack_alloc_size) {                                  \
       /* If the buffer is small enough, allocate it on the stack */            \
       size_t cobhan_buffer##_cobhan_buffer_allocation_size =                   \
           calculate_cobhan_buffer_allocation_size(buffer_size);                \
-      debug_log_alloca(function_name, #cobhan_buffer,                          \
-                       cobhan_buffer##_cobhan_buffer_allocation_size);         \
+      logger.debug_log_alloca(function_name, #cobhan_buffer,                   \
+                              cobhan_buffer##_cobhan_buffer_allocation_size);  \
       cobhan_buffer =                                                          \
           (char *)alloca(cobhan_buffer##_cobhan_buffer_allocation_size);       \
-      configure_cbuffer(cobhan_buffer, buffer_size);                           \
+      configure_cbuffer(logger, cobhan_buffer, buffer_size);                   \
     } else {                                                                   \
       /* Otherwise, allocate it on the heap */                                 \
-      unique_ptr = heap_allocate_cbuffer(#cobhan_buffer, buffer_size);         \
+      unique_ptr = heap_allocate_cbuffer(logger, #cobhan_buffer, buffer_size); \
       cobhan_buffer = unique_ptr.get();                                        \
     }                                                                          \
     if (unlikely(cobhan_buffer == nullptr)) {                                  \
-      log_error_and_throw(function_name,                                       \
-                          "Failed to allocate " #cobhan_buffer);               \
+      logger.log_error_and_throw(function_name,                                \
+                                 "Failed to allocate " #cobhan_buffer);        \
     }                                                                          \
   } while (0);
 
-#define ALLOCATE_CBUFFER(cobhan_buffer, buffer_size, max_stack_alloc_size,     \
-                         function_name)                                        \
+#define ALLOCATE_CBUFFER(logger, cobhan_buffer, buffer_size,                   \
+                         max_stack_alloc_size, function_name)                  \
   std::unique_ptr<char[]> cobhan_buffer##_unique_ptr;                          \
-  ALLOCATE_CBUFFER_UNIQUE_PTR(cobhan_buffer, buffer_size,                      \
+  ALLOCATE_CBUFFER_UNIQUE_PTR(logger, cobhan_buffer, buffer_size,              \
                               cobhan_buffer##_unique_ptr,                      \
                               max_stack_alloc_size, function_name);
 

package/src/cobhan_napi_interop.h

@@ -9,14 +9,15 @@
 std::string napi_status_to_string(napi_status status);
 
 __attribute__((always_inline)) inline size_t
-nstring_utf8_byte_length(Napi::Env &env, Napi::String &str) {
+nstring_utf8_byte_length(Napi::Env &env, Logger &logger, Napi::String &str) {
   napi_status status;
   size_t utf8_length;
 
   status = napi_get_value_string_utf8(env, str, nullptr, 0, &utf8_length);
   if (unlikely(status != napi_ok)) {
-    error_log(__func__, "napi_get_value_string_utf8 length check failed: " +
-                            napi_status_to_string(status));
+    logger.error_log(__func__,
+                     "napi_get_value_string_utf8 length check failed: " +
+                         napi_status_to_string(status));
     return (size_t)(-1);
   }
 
@@ -24,28 +25,23 @@ nstring_utf8_byte_length(Napi::Env &env, Napi::String &str) {
 }
 
 __attribute__((always_inline)) inline char *
-copy_nstring_to_cbuffer(Napi::Env &env, Napi::String &str,
+copy_nstring_to_cbuffer(Napi::Env &env, Logger &logger, Napi::String &str,
                         size_t str_utf8_byte_length, char *cobhan_buffer,
                         size_t *byte_length) {
 
   size_t cobhan_buffer_size_bytes = cbuffer_byte_length(cobhan_buffer);
   if (unlikely(cobhan_buffer_size_bytes <= 0)) {
-    error_log(__func__, "Invalid cobhan buffer byte length");
+    logger.error_log(__func__, "Invalid cobhan buffer byte length");
     return nullptr;
   }
 
   if (cobhan_buffer_size_bytes < str_utf8_byte_length) {
-    error_log(__func__, "String too large for cobhan buffer");
+    logger.error_log(__func__, "String too large for cobhan buffer");
     return nullptr;
   }
 
-  if (unlikely(verbose_flag)) {
-    debug_log(__func__,
-              "Copying " + std::to_string(str_utf8_byte_length) + " bytes to " +
-                  format_ptr(cbuffer_data_ptr(cobhan_buffer)) + " - " +
-                  format_ptr((cbuffer_data_ptr(cobhan_buffer) +
-                              str_utf8_byte_length)));
-  }
+  logger.debug_log_copy_buffer(__func__, cbuffer_data_ptr(cobhan_buffer),
+                               str_utf8_byte_length);
 
   napi_status status;
   size_t copied_bytes;
@@ -55,31 +51,31 @@ copy_nstring_to_cbuffer(Napi::Env &env, Napi::String &str,
   status = napi_get_value_string_utf8(env, str, cbuffer_data_ptr(cobhan_buffer),
                                       str_utf8_byte_length + 1, &copied_bytes);
   if (unlikely(status != napi_ok)) {
-    error_log(__func__, "Napi utf8 string conversion failure: " +
-                            napi_status_to_string(status));
+    logger.error_log(__func__, "Napi utf8 string conversion failure: " +
+                                   napi_status_to_string(status));
     return nullptr;
   }
 
   if (unlikely(copied_bytes != str_utf8_byte_length)) {
-    error_log(__func__, "Did not copy expected number of bytes " +
-                            std::to_string(str_utf8_byte_length) + " copied " +
-                            std::to_string(copied_bytes));
+    logger.error_log(__func__, "Did not copy expected number of bytes " +
+                                   std::to_string(str_utf8_byte_length) +
+                                   " copied " + std::to_string(copied_bytes));
     return nullptr;
   }
 
-  configure_cbuffer(cobhan_buffer, copied_bytes);
+  configure_cbuffer(logger, cobhan_buffer, copied_bytes);
 
   *byte_length = copied_bytes;
   return cobhan_buffer;
 }
 
 __attribute__((always_inline)) inline Napi::String
-cbuffer_to_nstring(Napi::Env &env, char *cobhan_buffer) {
+cbuffer_to_nstring(Napi::Env &env, Logger &logger, char *cobhan_buffer) {
   napi_value output;
 
   int32_t cobhan_buffer_size_bytes = cbuffer_byte_length(cobhan_buffer);
   if (cobhan_buffer_size_bytes <= 0) {
-    log_error_and_throw(__func__, "Invalid cobhan buffer byte length");
+    logger.log_error_and_throw(__func__, "Invalid cobhan buffer byte length");
   }
 
   // Using C function because it allows length delimited input
@@ -87,18 +83,18 @@ cbuffer_to_nstring(Napi::Env &env, char *cobhan_buffer) {
       env, cbuffer_data_ptr(cobhan_buffer), cobhan_buffer_size_bytes, &output);
 
   if (unlikely(status != napi_ok)) {
-    log_error_and_throw(__func__, "napi_create_string_utf8 failed: " +
-                                      napi_status_to_string(status));
+    logger.log_error_and_throw(__func__, "napi_create_string_utf8 failed: " +
+                                             napi_status_to_string(status));
   }
 
   return Napi::String(env, output);
 }
 
 __attribute__((always_inline)) inline Napi::Buffer<unsigned char>
-cbuffer_to_nbuffer(Napi::Env &env, char *cobhan_buffer) {
+cbuffer_to_nbuffer(Napi::Env &env, Logger &logger, char *cobhan_buffer) {
   int32_t cobhan_buffer_byte_length = cbuffer_byte_length(cobhan_buffer);
   if (unlikely(cobhan_buffer_byte_length <= 0)) {
-    log_error_and_throw(__func__, "Invalid cobhan buffer byte length");
+    logger.log_error_and_throw(__func__, "Invalid cobhan buffer byte length");
   }
 
   Napi::Buffer<unsigned char> nbuffer = Napi::Buffer<unsigned char>::Copy(
@@ -106,91 +102,90 @@ cbuffer_to_nbuffer(Napi::Env &env, char *cobhan_buffer) {
       cobhan_buffer_byte_length);
 
   if (unlikely(nbuffer.ByteLength() != (size_t)cobhan_buffer_byte_length)) {
-    log_error_and_throw(__func__,
-                        "Failed to copy cobhan buffer to napi buffer");
+    logger.log_error_and_throw(__func__,
+                               "Failed to copy cobhan buffer to napi buffer");
   }
 
   return nbuffer;
 }
 
 __attribute__((always_inline)) inline char *
-copy_nbuffer_to_cbuffer(Napi::Env &env, Napi::Buffer<unsigned char> &nbuffer,
+copy_nbuffer_to_cbuffer(Napi::Env &env, Logger &logger,
+                        Napi::Buffer<unsigned char> &nbuffer,
                         char *cobhan_buffer) {
 
   int32_t cobhan_buffer_size_bytes = cbuffer_byte_length(cobhan_buffer);
   if (unlikely(cobhan_buffer_size_bytes <= 0)) {
-    error_log(__func__, "Invalid cobhan buffer byte length");
+    logger.error_log(__func__, "Invalid cobhan buffer byte length");
     return nullptr;
   }
 
   size_t nbuffer_byte_length = nbuffer.ByteLength();
   if (nbuffer_byte_length > INT32_MAX ||
       cobhan_buffer_size_bytes < (int32_t)nbuffer_byte_length) {
-    error_log(__func__, "Buffer too large for cobhan buffer");
+    logger.error_log(__func__, "Buffer too large for cobhan buffer");
     return nullptr;
   }
 
-  if (unlikely(verbose_flag)) {
-    debug_log(__func__,
-              "Copying " + std::to_string(nbuffer_byte_length) + " bytes to " +
-                  format_ptr(cbuffer_data_ptr(cobhan_buffer)) + " - " +
-                  format_ptr(
-                      (cbuffer_data_ptr(cobhan_buffer) + nbuffer_byte_length)));
-  }
+  logger.debug_log_copy_buffer(__func__, cbuffer_data_ptr(cobhan_buffer),
+                               nbuffer_byte_length);
 
   memcpy(cbuffer_data_ptr(cobhan_buffer), nbuffer.Data(), nbuffer_byte_length);
-  configure_cbuffer(cobhan_buffer, nbuffer_byte_length);
+  configure_cbuffer(logger, cobhan_buffer, nbuffer_byte_length);
   return cobhan_buffer;
 }
 
 // These are macros due to the use of alloca()
 
-#define NAPI_STRING_TO_CBUFFER(env, napi_string, cobhan_buffer, bytes_copied,  \
-                               max_stack_alloc_size, function_name)            \
+#define NAPI_STRING_TO_CBUFFER(env, logger, napi_string, cobhan_buffer,        \
+                               bytes_copied, max_stack_alloc_size,             \
+                               function_name)                                  \
   std::unique_ptr<char[]> napi_string##_unique_ptr;                            \
   do {                                                                         \
     /* Determine size */                                                       \
     size_t napi_string##_utf8_byte_length =                                    \
-        nstring_utf8_byte_length(env, napi_string);                            \
+        nstring_utf8_byte_length(env, logger, napi_string);                    \
     if (unlikely(napi_string##_utf8_byte_length == (size_t)(-1))) {            \
-      log_error_and_throw(function_name,                                       \
-                          "Failed to get " #napi_string " utf8 length");       \
+      logger.log_error_and_throw(function_name, "Failed to get " #napi_string  \
+                                                " utf8 length");               \
     }                                                                          \
     if (unlikely(napi_string##_utf8_byte_length == 0)) {                       \
-      log_error_and_throw(function_name, #napi_string " is empty");            \
+      logger.log_error_and_throw(function_name, #napi_string " is empty");     \
     }                                                                          \
     /* Allocate */                                                             \
-    ALLOCATE_CBUFFER_UNIQUE_PTR(cobhan_buffer, napi_string##_utf8_byte_length, \
-                                napi_string##_unique_ptr,                      \
-                                max_stack_alloc_size, function_name);          \
+    ALLOCATE_CBUFFER_UNIQUE_PTR(                                               \
+        logger, cobhan_buffer, napi_string##_utf8_byte_length,                 \
+        napi_string##_unique_ptr, max_stack_alloc_size, function_name);        \
     /* Copy */                                                                 \
-    cobhan_buffer = copy_nstring_to_cbuffer(env, napi_string,                  \
+    cobhan_buffer = copy_nstring_to_cbuffer(env, logger, napi_string,          \
                                             napi_string##_utf8_byte_length,    \
                                             cobhan_buffer, &bytes_copied);     \
     if (unlikely(cobhan_buffer == nullptr)) {                                  \
-      log_error_and_throw(function_name,                                       \
-                          "Failed to copy " #napi_string " to cobhan buffer"); \
+      logger.log_error_and_throw(function_name, "Failed to copy " #napi_string \
+                                                " to cobhan buffer");          \
     }                                                                          \
   } while (0);
 
-#define NAPI_BUFFER_TO_CBUFFER(env, napi_buffer, cobhan_buffer, bytes_copied,  \
-                               max_stack_alloc_size, function_name)            \
+#define NAPI_BUFFER_TO_CBUFFER(env, logger, napi_buffer, cobhan_buffer,        \
+                               bytes_copied, max_stack_alloc_size,             \
+                               function_name)                                  \
   std::unique_ptr<char[]> napi_buffer##_unique_ptr;                            \
   do {                                                                         \
     /* Determine size */                                                       \
     size_t napi_buffer##_byte_length = napi_buffer.ByteLength();               \
     if (unlikely(napi_buffer##_byte_length == 0)) {                            \
-      log_error_and_throw(function_name, #napi_buffer " is empty");            \
+      logger.log_error_and_throw(function_name, #napi_buffer " is empty");     \
     }                                                                          \
     /* Allocate */                                                             \
-    ALLOCATE_CBUFFER_UNIQUE_PTR(cobhan_buffer, napi_buffer##_byte_length,      \
-                                napi_buffer##_unique_ptr,                      \
-                                max_stack_alloc_size, function_name);          \
+    ALLOCATE_CBUFFER_UNIQUE_PTR(                                               \
+        logger, cobhan_buffer, napi_buffer##_byte_length,                      \
+        napi_buffer##_unique_ptr, max_stack_alloc_size, function_name);        \
     /* Copy */                                                                 \
-    cobhan_buffer = copy_nbuffer_to_cbuffer(env, napi_buffer, cobhan_buffer);  \
+    cobhan_buffer =                                                            \
+        copy_nbuffer_to_cbuffer(env, logger, napi_buffer, cobhan_buffer);      \
     if (unlikely(cobhan_buffer == nullptr)) {                                  \
-      log_error_and_throw(function_name,                                       \
-                          "Failed to copy " #napi_buffer " to cobhan buffer"); \
+      logger.log_error_and_throw(function_name, "Failed to copy " #napi_buffer \
+                                                " to cobhan buffer");          \
     }                                                                          \
     bytes_copied = napi_buffer##_byte_length;                                  \
   } while (0);

package/src/logging.cc

@@ -1,2 +1,218 @@
-#include <cstdint>
-__attribute__((used)) int32_t verbose_flag = 0;
+#include "logging.h"
+
+Logger::Logger() {}
+
+Logger::Logger(Napi::Function new_log_hook) {
+  if (unlikely(new_log_hook.IsEmpty())) {
+    throw new std::runtime_error("new_log_hook cannot be nullptr");
+  }
+  log_hook = Napi::Persistent(new_log_hook);
+}
+
+Logger::~Logger() {
+  if (!log_hook.IsEmpty()) {
+    log_hook.Unref();
+  }
+}
+
+void Logger::set_log_hook(Napi::Function new_log_hook) {
+  if (unlikely(new_log_hook.IsEmpty())) {
+    throw new std::runtime_error("new_log_hook cannot be nullptr");
+  }
+  if (!log_hook.IsEmpty()) {
+    log_hook.Unref();
+  }
+  log_hook = Napi::Persistent(new_log_hook);
+}
+
+void Logger::set_verbose_flag(int32_t verbose) { verbose_flag = verbose; }
+
+void Logger::debug_log(const char *function_name, const char *message) {
+  if (unlikely(verbose_flag)) {
+    if (unlikely(log_hook.IsEmpty())) {
+      stderr_debug_log(function_name, message);
+    } else {
+      Napi::Env env = log_hook.Env();
+      Napi::HandleScope scope(env);
+      Napi::Function log_hook_function = log_hook.Value();
+      log_hook_function.Call(
+          {Napi::Number::New(env, posix_log_level_debug),
+           Napi::String::New(env, asherah_node_prefix + function_name + ": " +
+                                      message)});
+    }
+  }
+}
+
+void Logger::debug_log(const char *function_name, std::string message) {
+  if (unlikely(verbose_flag)) {
+    if (unlikely(log_hook.IsEmpty())) {
+      stderr_debug_log(function_name, message);
+    } else {
+      Napi::Env env = log_hook.Env();
+      Napi::HandleScope scope(env);
+      Napi::Function log_hook_function = log_hook.Value();
+      log_hook_function.Call(
+          {Napi::Number::New(env, posix_log_level_debug),
+           Napi::String::New(env, asherah_node_prefix + function_name + ": " +
+                                      message)});
+    }
+  }
+}
+
+void Logger::debug_log_alloca(const char *function_name,
+                              const char *variable_name, size_t length) {
+  if (unlikely(verbose_flag)) {
+    if (unlikely(log_hook.IsEmpty())) {
+      stderr_debug_log_alloca(function_name, variable_name, length);
+    } else {
+      Napi::Env env = log_hook.Env();
+      Napi::HandleScope scope(env);
+      Napi::Function log_hook_function = log_hook.Value();
+      log_hook_function.Call(
+          {Napi::Number::New(env, posix_log_level_debug),
+           Napi::String::New(env, asherah_node_prefix + function_name +
+                                      ": Calling alloca(" +
+                                      std::to_string(length) +
+                                      ") (stack) for " + variable_name)});
+    }
+  }
+}
+
+void Logger::debug_log_new(const char *function_name, const char *variable_name,
+                           size_t length) {
+  if (unlikely(verbose_flag)) {
+    if (unlikely(log_hook.IsEmpty())) {
+      stderr_debug_log_new(function_name, variable_name, length);
+    } else {
+      Napi::Env env = log_hook.Env();
+      Napi::HandleScope scope(env);
+      Napi::Function log_hook_function = log_hook.Value();
+      log_hook_function.Call(
+          {Napi::Number::New(env, posix_log_level_debug),
+           Napi::String::New(env, asherah_node_prefix + function_name +
+                                      ": Calling new[" +
+                                      std::to_string(length) + "] (heap) for " +
+                                      variable_name)});
+    }
+  }
+}
+
+void Logger::debug_log_copy_buffer(const char *function_name,
+                                   const char *buffer, size_t length) {
+  if (unlikely(verbose_flag)) {
+    debug_log(__func__, "Copying " + std::to_string(length) + " bytes to " +
+                            format_ptr(buffer) + " - " +
+                            format_ptr(buffer + length));
+  }
+}
+
+void Logger::debug_log_configure_cbuffer(const char *function_name,
+                                         const char *variable_name,
+                                         size_t length) {
+  if (unlikely(verbose_flag)) {
+    debug_log(__func__, "configure_cbuffer(" + format_ptr(variable_name) +
+                            ", " + std::to_string(length) + ")");
+  }
+}
+
+void Logger::error_log(const char *function_name, const char *message) {
+  if (unlikely(verbose_flag)) {
+    if (unlikely(log_hook.IsEmpty())) {
+      stderr_error_log(function_name, message);
+    } else {
+      Napi::Env env = log_hook.Env();
+      Napi::HandleScope scope(env);
+      Napi::Function log_hook_function = log_hook.Value();
+      log_hook_function.Call(
+          {Napi::Number::New(env, posix_log_level_error),
+           Napi::String::New(env, asherah_node_prefix + function_name + ": " +
+                                      message)});
+    }
+  }
+}
+
+void Logger::error_log(const char *function_name, std::string message) {
+  if (unlikely(verbose_flag)) {
+    if (unlikely(log_hook.IsEmpty())) {
+      stderr_error_log(function_name, message);
+    } else {
+      Napi::Env env = log_hook.Env();
+      Napi::HandleScope scope(env);
+      Napi::Function log_hook_function = log_hook.Value();
+      log_hook_function.Call(
+          {Napi::Number::New(env, posix_log_level_error),
+           Napi::String::New(env, asherah_node_prefix + function_name + ": " +
+                                      message)});
+    }
+  }
+}
+
+__attribute__((always_inline)) inline void
+Logger::stderr_debug_log(const char *function_name, const char *message) {
+  if (unlikely(verbose_flag)) {
+    std::cerr << "asherah-node: [DEBUG] " << function_name << ": " << message
+              << std::endl
+              << std::flush;
+  }
+}
+
+__attribute__((always_inline)) inline void
+Logger::stderr_debug_log(const char *function_name, std::string message) {
+  if (unlikely(verbose_flag)) {
+    std::cerr << "asherah-node: [DEBUG] " << function_name << ": " << message
+              << std::endl
+              << std::flush;
+  }
+}
+
+__attribute__((always_inline)) inline void
+Logger::stderr_debug_log_alloca(const char *function_name,
+                                const char *variable_name, size_t length) {
+  if (unlikely(verbose_flag)) {
+    std::cerr << "asherah-node: [DEBUG] " << function_name
+              << ": Calling alloca(" << length << ") (stack) for "
+              << variable_name << std::endl
+              << std::flush;
+  }
+}
+
+__attribute__((always_inline)) inline void
+Logger::stderr_debug_log_new(const char *function_name,
+                             const char *variable_name, size_t length) {
+  if (unlikely(verbose_flag)) {
+    std::cerr << "asherah-node: [DEBUG] " << function_name << ": Calling new["
+              << length << "] (heap) for " << variable_name << std::endl
+              << std::flush;
+  }
+}
+
+__attribute__((always_inline)) inline void
+Logger::stderr_error_log(const char *function_name, const char *message) {
+  if (unlikely(verbose_flag)) {
+    std::cerr << "asherah-node: [ERROR] " << function_name << ": " << message
+              << std::endl
+              << std::flush;
+  }
+}
+
+__attribute__((always_inline)) inline void
+Logger::stderr_error_log(const char *function_name, std::string message) {
+  if (unlikely(verbose_flag)) {
+    std::cerr << "asherah-node: [ERROR] " << function_name << ": " << message
+              << std::endl
+              << std::flush;
+  }
+}
+
+__attribute__((always_inline)) inline std::string
+Logger::format_ptr(const char *ptr) {
+  std::ostringstream ss;
+  ss << "0x" << std::hex << (intptr_t)ptr;
+  return ss.str();
+}
+
+__attribute__((always_inline, noreturn)) inline void
+Logger::log_error_and_throw(const char *function_name, std::string error_msg) {
+  error_log(function_name, error_msg);
+  throw new std::runtime_error(function_name + (": " + error_msg));
+}