[logger] Refactor to reduce code duplication and flash size (#13750)

esphome/components/logger/logger.cpp

@@ -36,9 +36,7 @@ void HOT Logger::log_vprintf_(uint8_t level, const char *tag, int line, const ch
 
   // Fast path: main thread, no recursion (99.9% of all logs)
   if (is_main_task && !this->main_task_recursion_guard_) [[likely]] {
-    RecursionGuard guard(this->main_task_recursion_guard_);
-    // Format and send to both console and callbacks
-    this->log_message_to_buffer_and_send_(level, tag, line, format, args);
+    this->log_message_to_buffer_and_send_(this->main_task_recursion_guard_, level, tag, line, format, args);
     return;
   }
 
@@ -101,12 +99,9 @@ void Logger::log_vprintf_non_main_thread_(uint8_t level, const char *tag, int li
     static const size_t MAX_CONSOLE_LOG_MSG_SIZE = 144;
 #endif
     char console_buffer[MAX_CONSOLE_LOG_MSG_SIZE];  // MUST be stack allocated for thread safety
-    uint16_t buffer_at = 0;                         // Initialize buffer position
-    this->format_log_to_buffer_with_terminator_(level, tag, line, format, args, console_buffer, &buffer_at,
-                                                MAX_CONSOLE_LOG_MSG_SIZE);
-    // Add newline before writing to console
-    this->add_newline_to_buffer_(console_buffer, &buffer_at, MAX_CONSOLE_LOG_MSG_SIZE);
-    this->write_msg_(console_buffer, buffer_at);
+    LogBuffer buf{console_buffer, MAX_CONSOLE_LOG_MSG_SIZE};
+    this->format_log_to_buffer_with_terminator_(level, tag, line, format, args, buf);
+    this->write_to_console_(buf);
   }
 
   // RAII guard automatically resets on return
@@ -117,9 +112,7 @@ void HOT Logger::log_vprintf_(uint8_t level, const char *tag, int line, const ch
   if (level > this->level_for(tag) || global_recursion_guard_)
     return;
 
-  RecursionGuard guard(global_recursion_guard_);
-  // Format and send to both console and callbacks
-  this->log_message_to_buffer_and_send_(level, tag, line, format, args);
+  this->log_message_to_buffer_and_send_(global_recursion_guard_, level, tag, line, format, args);
 }
 #endif  // USE_ESP32 / USE_HOST / USE_LIBRETINY
 
@@ -135,28 +128,7 @@ void Logger::log_vprintf_(uint8_t level, const char *tag, int line, const __Flas
   if (level > this->level_for(tag) || global_recursion_guard_)
     return;
 
-  RecursionGuard guard(global_recursion_guard_);
-  this->tx_buffer_at_ = 0;
-
-  // Write header, format body directly from flash, and write footer
-  this->write_header_to_buffer_(level, tag, line, nullptr, this->tx_buffer_, &this->tx_buffer_at_,
-                                this->tx_buffer_size_);
-  this->format_body_to_buffer_P_(this->tx_buffer_, &this->tx_buffer_at_, this->tx_buffer_size_,
-                                 reinterpret_cast<PGM_P>(format), args);
-  this->write_footer_to_buffer_(this->tx_buffer_, &this->tx_buffer_at_, this->tx_buffer_size_);
-
-  // Ensure null termination
-  uint16_t null_pos = this->tx_buffer_at_ >= this->tx_buffer_size_ ? this->tx_buffer_size_ - 1 : this->tx_buffer_at_;
-  this->tx_buffer_[null_pos] = '\0';
-
-  // Listeners get message first (before console write)
-#ifdef USE_LOG_LISTENERS
-  for (auto *listener : this->log_listeners_)
-    listener->on_log(level, tag, this->tx_buffer_, this->tx_buffer_at_);
-#endif
-
-  // Write to console
-  this->write_tx_buffer_to_console_();
+  this->log_message_to_buffer_and_send_(global_recursion_guard_, level, tag, line, format, args);
 }
 #endif  // USE_STORE_LOG_STR_IN_FLASH
 
@@ -215,10 +187,11 @@ void Logger::process_messages_() {
     logger::TaskLogBufferHost::LogMessage *message;
     while (this->log_buffer_->get_message_main_loop(&message)) {
       const char *thread_name = message->thread_name[0] != '\0' ? message->thread_name : nullptr;
+      LogBuffer buf{this->tx_buffer_, this->tx_buffer_size_};
       this->format_buffered_message_and_notify_(message->level, message->tag, message->line, thread_name, message->text,
-                                                message->text_length);
+                                                message->text_length, buf);
       this->log_buffer_->release_message_main_loop();
-      this->write_tx_buffer_to_console_();
+      this->write_log_buffer_to_console_(buf);
     }
 #elif defined(USE_ESP32)
     logger::TaskLogBuffer::LogMessage *message;
@@ -226,22 +199,24 @@ void Logger::process_messages_() {
     void *received_token;
     while (this->log_buffer_->borrow_message_main_loop(&message, &text, &received_token)) {
       const char *thread_name = message->thread_name[0] != '\0' ? message->thread_name : nullptr;
+      LogBuffer buf{this->tx_buffer_, this->tx_buffer_size_};
       this->format_buffered_message_and_notify_(message->level, message->tag, message->line, thread_name, text,
-                                                message->text_length);
+                                                message->text_length, buf);
       // Release the message to allow other tasks to use it as soon as possible
       this->log_buffer_->release_message_main_loop(received_token);
-      this->write_tx_buffer_to_console_();
+      this->write_log_buffer_to_console_(buf);
     }
 #elif defined(USE_LIBRETINY)
     logger::TaskLogBufferLibreTiny::LogMessage *message;
     const char *text;
     while (this->log_buffer_->borrow_message_main_loop(&message, &text)) {
       const char *thread_name = message->thread_name[0] != '\0' ? message->thread_name : nullptr;
+      LogBuffer buf{this->tx_buffer_, this->tx_buffer_size_};
       this->format_buffered_message_and_notify_(message->level, message->tag, message->line, thread_name, text,
-                                                message->text_length);
+                                                message->text_length, buf);
       // Release the message to allow other tasks to use it as soon as possible
       this->log_buffer_->release_message_main_loop();
-      this->write_tx_buffer_to_console_();
+      this->write_log_buffer_to_console_(buf);
     }
 #endif
   }

esphome/components/logger/logger.h

@@ -2,6 +2,7 @@
 
 #include <cstdarg>
 #include <map>
+#include <type_traits>
 #if defined(USE_ESP32) || defined(USE_HOST)
 #include <pthread.h>
 #endif
@@ -123,6 +124,163 @@ static constexpr uint16_t MAX_HEADER_SIZE = 128;
 // "0x" + 2 hex digits per byte + '\0'
 static constexpr size_t MAX_POINTER_REPRESENTATION = 2 + sizeof(void *) * 2 + 1;
 
+// Buffer wrapper for log formatting functions
+struct LogBuffer {
+  char *data;
+  uint16_t size;
+  uint16_t pos{0};
+  // Replaces the null terminator with a newline for console output.
+  // Must be called after notify_listeners_() since listeners need null-terminated strings.
+  // Console output uses length-based writes (buf.pos), so null terminator is not needed.
+  void terminate_with_newline() {
+    if (this->pos < this->size) {
+      this->data[this->pos++] = '\n';
+    } else if (this->size > 0) {
+      // Buffer was full - replace last char with newline to ensure it's visible
+      this->data[this->size - 1] = '\n';
+      this->pos = this->size;
+    }
+  }
+  void HOT write_header(uint8_t level, const char *tag, int line, const char *thread_name) {
+    // Early return if insufficient space - intentionally don't update pos to prevent partial writes
+    if (this->pos + MAX_HEADER_SIZE > this->size)
+      return;
+
+    char *p = this->current_();
+
+    // Write ANSI color
+    this->write_ansi_color_(p, level);
+
+    // Construct: [LEVEL][tag:line]
+    *p++ = '[';
+    if (level != 0) {
+      if (level >= 7) {
+        *p++ = 'V';  // VERY_VERBOSE = "VV"
+        *p++ = 'V';
+      } else {
+        *p++ = LOG_LEVEL_LETTER_CHARS[level];
+      }
+    }
+    *p++ = ']';
+    *p++ = '[';
+
+    // Copy tag
+    this->copy_string_(p, tag);
+
+    *p++ = ':';
+
+    // Format line number without modulo operations
+    if (line > 999) [[unlikely]] {
+      int thousands = line / 1000;
+      *p++ = '0' + thousands;
+      line -= thousands * 1000;
+    }
+    int hundreds = line / 100;
+    int remainder = line - hundreds * 100;
+    int tens = remainder / 10;
+    *p++ = '0' + hundreds;
+    *p++ = '0' + tens;
+    *p++ = '0' + (remainder - tens * 10);
+    *p++ = ']';
+
+#if defined(USE_ESP32) || defined(USE_LIBRETINY) || defined(USE_ZEPHYR) || defined(USE_HOST)
+    // Write thread name with bold red color
+    if (thread_name != nullptr) {
+      this->write_ansi_color_(p, 1);  // Bold red for thread name
+      *p++ = '[';
+      this->copy_string_(p, thread_name);
+      *p++ = ']';
+      this->write_ansi_color_(p, level);  // Restore original color
+    }
+#endif
+
+    *p++ = ':';
+    *p++ = ' ';
+
+    this->pos = p - this->data;
+  }
+  void HOT format_body(const char *format, va_list args) {
+    this->format_vsnprintf_(format, args);
+    this->finalize_();
+  }
+#ifdef USE_STORE_LOG_STR_IN_FLASH
+  void HOT format_body_P(PGM_P format, va_list args) {
+    this->format_vsnprintf_P_(format, args);
+    this->finalize_();
+  }
+#endif
+  void write_body(const char *text, uint16_t text_length) {
+    this->write_(text, text_length);
+    this->finalize_();
+  }
+
+ private:
+  bool full_() const { return this->pos >= this->size; }
+  uint16_t remaining_() const { return this->size - this->pos; }
+  char *current_() { return this->data + this->pos; }
+  void write_(const char *value, uint16_t length) {
+    const uint16_t available = this->remaining_();
+    const uint16_t copy_len = (length < available) ? length : available;
+    if (copy_len > 0) {
+      memcpy(this->current_(), value, copy_len);
+      this->pos += copy_len;
+    }
+  }
+  void finalize_() {
+    // Write color reset sequence
+    static constexpr uint16_t RESET_COLOR_LEN = sizeof(ESPHOME_LOG_RESET_COLOR) - 1;
+    this->write_(ESPHOME_LOG_RESET_COLOR, RESET_COLOR_LEN);
+    // Null terminate
+    this->data[this->full_() ? this->size - 1 : this->pos] = '\0';
+  }
+  void strip_trailing_newlines_() {
+    while (this->pos > 0 && this->data[this->pos - 1] == '\n')
+      this->pos--;
+  }
+  void process_vsnprintf_result_(int ret) {
+    if (ret < 0)
+      return;
+    const uint16_t rem = this->remaining_();
+    this->pos += (ret >= rem) ? (rem - 1) : static_cast<uint16_t>(ret);
+    this->strip_trailing_newlines_();
+  }
+  void format_vsnprintf_(const char *format, va_list args) {
+    if (this->full_())
+      return;
+    this->process_vsnprintf_result_(vsnprintf(this->current_(), this->remaining_(), format, args));
+  }
+#ifdef USE_STORE_LOG_STR_IN_FLASH
+  void format_vsnprintf_P_(PGM_P format, va_list args) {
+    if (this->full_())
+      return;
+    this->process_vsnprintf_result_(vsnprintf_P(this->current_(), this->remaining_(), format, args));
+  }
+#endif
+  // Write ANSI color escape sequence to buffer, updates pointer in place
+  // Caller is responsible for ensuring buffer has sufficient space
+  void write_ansi_color_(char *&p, uint8_t level) {
+    if (level == 0)
+      return;
+    // Direct buffer fill: "\033[{bold};3{color}m" (7 bytes)
+    *p++ = '\033';
+    *p++ = '[';
+    *p++ = (level == 1) ? '1' : '0';  // Only ERROR is bold
+    *p++ = ';';
+    *p++ = '3';
+    *p++ = LOG_LEVEL_COLOR_DIGIT[level];
+    *p++ = 'm';
+  }
+  // Copy string without null terminator, updates pointer in place
+  // Caller is responsible for ensuring buffer has sufficient space
+  void copy_string_(char *&p, const char *str) {
+    const size_t len = strlen(str);
+    // NOLINTNEXTLINE(bugprone-not-null-terminated-result) - intentionally no null terminator, building string piece by
+    // piece
+    memcpy(p, str, len);
+    p += len;
+  }
+};
+
 #if defined(USE_ESP32) || defined(USE_ESP8266) || defined(USE_RP2040) || defined(USE_LIBRETINY) || defined(USE_ZEPHYR)
 /** Enum for logging UART selection
  *
@@ -260,114 +418,83 @@ class Logger : public Component {
 #endif
 #endif
   void process_messages_();
-  void write_msg_(const char *msg, size_t len);
+  void write_msg_(const char *msg, uint16_t len);
 
   // Format a log message with printf-style arguments and write it to a buffer with header, footer, and null terminator
-  // It's the caller's responsibility to initialize buffer_at (typically to 0)
   inline void HOT format_log_to_buffer_with_terminator_(uint8_t level, const char *tag, int line, const char *format,
-                                                        va_list args, char *buffer, uint16_t *buffer_at,
-                                                        uint16_t buffer_size) {
+                                                        va_list args, LogBuffer &buf) {
 #if defined(USE_ESP32) || defined(USE_LIBRETINY) || defined(USE_HOST)
-    this->write_header_to_buffer_(level, tag, line, this->get_thread_name_(), buffer, buffer_at, buffer_size);
+    buf.write_header(level, tag, line, this->get_thread_name_());
 #elif defined(USE_ZEPHYR)
-    char buff[MAX_POINTER_REPRESENTATION];
-    this->write_header_to_buffer_(level, tag, line, this->get_thread_name_(buff), buffer, buffer_at, buffer_size);
+    char tmp[MAX_POINTER_REPRESENTATION];
+    buf.write_header(level, tag, line, this->get_thread_name_(tmp));
 #else
-    this->write_header_to_buffer_(level, tag, line, nullptr, buffer, buffer_at, buffer_size);
+    buf.write_header(level, tag, line, nullptr);
 #endif
-    this->format_body_to_buffer_(buffer, buffer_at, buffer_size, format, args);
-    this->write_footer_to_buffer_(buffer, buffer_at, buffer_size);
-
-    // Always ensure the buffer has a null terminator, even if we need to
-    // overwrite the last character of the actual content
-    if (*buffer_at >= buffer_size) {
-      buffer[buffer_size - 1] = '\0';  // Truncate and ensure null termination
-    } else {
-      buffer[*buffer_at] = '\0';  // Normal case, append null terminator
-    }
+    buf.format_body(format, args);
   }
 
-  // Helper to add newline to buffer before writing to console
-  // Modifies buffer_at to include the newline
-  inline void HOT add_newline_to_buffer_(char *buffer, uint16_t *buffer_at, uint16_t buffer_size) {
-    // Add newline - don't need to maintain null termination
-    // write_msg_ receives explicit length, so we can safely overwrite the null terminator
-    // This is safe because:
-    // 1. Callbacks already received the message (before we add newline)
-    // 2. write_msg_ receives the length explicitly (doesn't need null terminator)
-    if (*buffer_at < buffer_size) {
-      buffer[(*buffer_at)++] = '\n';
-    } else if (buffer_size > 0) {
-      // Buffer was full - replace last char with newline to ensure it's visible
-      buffer[buffer_size - 1] = '\n';
-      *buffer_at = buffer_size;
-    }
+#ifdef USE_STORE_LOG_STR_IN_FLASH
+  // Format a log message with flash string format and write it to a buffer with header, footer, and null terminator
+  inline void HOT format_log_to_buffer_with_terminator_P_(uint8_t level, const char *tag, int line,
+                                                          const __FlashStringHelper *format, va_list args,
+                                                          LogBuffer &buf) {
+    buf.write_header(level, tag, line, nullptr);
+    buf.format_body_P(reinterpret_cast<PGM_P>(format), args);
+  }
+#endif
+
+  // Helper to notify log listeners
+  inline void HOT notify_listeners_(uint8_t level, const char *tag, const LogBuffer &buf) {
+#ifdef USE_LOG_LISTENERS
+    for (auto *listener : this->log_listeners_)
+      listener->on_log(level, tag, buf.data, buf.pos);
+#endif
   }
 
-  // Helper to write tx_buffer_ to console if logging is enabled
-  // INTERNAL USE ONLY - offset > 0 requires length parameter to be non-null
-  inline void HOT write_tx_buffer_to_console_(uint16_t offset = 0, uint16_t *length = nullptr) {
-    if (this->baud_rate_ > 0) {
-      uint16_t *len_ptr = length ? length : &this->tx_buffer_at_;
-      this->add_newline_to_buffer_(this->tx_buffer_ + offset, len_ptr, this->tx_buffer_size_ - offset);
-      this->write_msg_(this->tx_buffer_ + offset, *len_ptr);
-    }
+  // Helper to write log buffer to console (replaces null terminator with newline and writes)
+  inline void HOT write_to_console_(LogBuffer &buf) {
+    buf.terminate_with_newline();
+    this->write_msg_(buf.data, buf.pos);
+  }
+
+  // Helper to write log buffer to console if logging is enabled
+  inline void HOT write_log_buffer_to_console_(LogBuffer &buf) {
+    if (this->baud_rate_ > 0)
+      this->write_to_console_(buf);
   }
 
   // Helper to format and send a log message to both console and listeners
-  inline void HOT log_message_to_buffer_and_send_(uint8_t level, const char *tag, int line, const char *format,
-                                                  va_list args) {
-    // Format to tx_buffer and prepare for output
-    this->tx_buffer_at_ = 0;  // Initialize buffer position
-    this->format_log_to_buffer_with_terminator_(level, tag, line, format, args, this->tx_buffer_, &this->tx_buffer_at_,
-                                                this->tx_buffer_size_);
-
-    // Listeners get message WITHOUT newline (for API/MQTT/syslog)
-#ifdef USE_LOG_LISTENERS
-    for (auto *listener : this->log_listeners_)
-      listener->on_log(level, tag, this->tx_buffer_, this->tx_buffer_at_);
+  // Template handles both const char* (RAM) and __FlashStringHelper* (flash) format strings
+  template<typename FormatType>
+  inline void HOT log_message_to_buffer_and_send_(bool &recursion_guard, uint8_t level, const char *tag, int line,
+                                                  FormatType format, va_list args) {
+    RecursionGuard guard(recursion_guard);
+    LogBuffer buf{this->tx_buffer_, this->tx_buffer_size_};
+#ifdef USE_STORE_LOG_STR_IN_FLASH
+    if constexpr (std::is_same_v<FormatType, const __FlashStringHelper *>) {
+      this->format_log_to_buffer_with_terminator_P_(level, tag, line, format, args, buf);
+    } else
 #endif
-
-    // Console gets message WITH newline (if platform needs it)
-    this->write_tx_buffer_to_console_();
+    {
+      this->format_log_to_buffer_with_terminator_(level, tag, line, format, args, buf);
+    }
+    this->notify_listeners_(level, tag, buf);
+    this->write_log_buffer_to_console_(buf);
   }
 
 #ifdef USE_ESPHOME_TASK_LOG_BUFFER
   // Helper to format a pre-formatted message from the task log buffer and notify listeners
   // Used by process_messages_ to avoid code duplication between ESP32 and host platforms
   inline void HOT format_buffered_message_and_notify_(uint8_t level, const char *tag, uint16_t line,
-                                                      const char *thread_name, const char *text, size_t text_length) {
-    this->tx_buffer_at_ = 0;
-    this->write_header_to_buffer_(level, tag, line, thread_name, this->tx_buffer_, &this->tx_buffer_at_,
-                                  this->tx_buffer_size_);
-    this->write_body_to_buffer_(text, text_length, this->tx_buffer_, &this->tx_buffer_at_, this->tx_buffer_size_);
-    this->write_footer_to_buffer_(this->tx_buffer_, &this->tx_buffer_at_, this->tx_buffer_size_);
-    this->tx_buffer_[this->tx_buffer_at_] = '\0';
-#ifdef USE_LOG_LISTENERS
-    for (auto *listener : this->log_listeners_)
-      listener->on_log(level, tag, this->tx_buffer_, this->tx_buffer_at_);
-#endif
+                                                      const char *thread_name, const char *text, uint16_t text_length,
+                                                      LogBuffer &buf) {
+    buf.write_header(level, tag, line, thread_name);
+    buf.write_body(text, text_length);
+    this->notify_listeners_(level, tag, buf);
   }
 #endif
 
-  // Write the body of the log message to the buffer
-  inline void write_body_to_buffer_(const char *value, size_t length, char *buffer, uint16_t *buffer_at,
-                                    uint16_t buffer_size) {
-    // Calculate available space
-    if (*buffer_at >= buffer_size)
-      return;
-    const uint16_t available = buffer_size - *buffer_at;
-
-    // Determine copy length (minimum of remaining capacity and string length)
-    const size_t copy_len = (length < static_cast<size_t>(available)) ? length : available;
-
-    // Copy the data
-    if (copy_len > 0) {
-      memcpy(buffer + *buffer_at, value, copy_len);
-      *buffer_at += copy_len;
-    }
-  }
-
 #ifndef USE_HOST
   const LogString *get_uart_selection_();
 #endif
@@ -421,7 +548,6 @@ class Logger : public Component {
 #endif
 
   // Group smaller types together at the end
-  uint16_t tx_buffer_at_{0};
   uint16_t tx_buffer_size_{0};
   uint8_t current_level_{ESPHOME_LOG_LEVEL_VERY_VERBOSE};
 #if defined(USE_ESP32) || defined(USE_ESP8266) || defined(USE_RP2040) || defined(USE_ZEPHYR)
@@ -525,117 +651,6 @@ class Logger : public Component {
   }
 #endif
 
-  static inline void copy_string(char *buffer, uint16_t &pos, const char *str) {
-    const size_t len = strlen(str);
-    // Intentionally no null terminator, building larger string
-    memcpy(buffer + pos, str, len);  // NOLINT(bugprone-not-null-terminated-result)
-    pos += len;
-  }
-
-  static inline void write_ansi_color_for_level(char *buffer, uint16_t &pos, uint8_t level) {
-    if (level == 0)
-      return;
-    // Construct ANSI escape sequence: "\033[{bold};3{color}m"
-    // Example: "\033[1;31m" for ERROR (bold red)
-    buffer[pos++] = '\033';
-    buffer[pos++] = '[';
-    buffer[pos++] = (level == 1) ? '1' : '0';  // Only ERROR is bold
-    buffer[pos++] = ';';
-    buffer[pos++] = '3';
-    buffer[pos++] = LOG_LEVEL_COLOR_DIGIT[level];
-    buffer[pos++] = 'm';
-  }
-
-  inline void HOT write_header_to_buffer_(uint8_t level, const char *tag, int line, const char *thread_name,
-                                          char *buffer, uint16_t *buffer_at, uint16_t buffer_size) {
-    uint16_t pos = *buffer_at;
-    // Early return if insufficient space - intentionally don't update buffer_at to prevent partial writes
-    if (pos + MAX_HEADER_SIZE > buffer_size)
-      return;
-
-    // Construct: <color>[LEVEL][tag:line]:
-    write_ansi_color_for_level(buffer, pos, level);
-    buffer[pos++] = '[';
-    if (level != 0) {
-      if (level >= 7) {
-        buffer[pos++] = 'V';  // VERY_VERBOSE = "VV"
-        buffer[pos++] = 'V';
-      } else {
-        buffer[pos++] = LOG_LEVEL_LETTER_CHARS[level];
-      }
-    }
-    buffer[pos++] = ']';
-    buffer[pos++] = '[';
-    copy_string(buffer, pos, tag);
-    buffer[pos++] = ':';
-    // Format line number without modulo operations (passed by value, safe to mutate)
-    if (line > 999) [[unlikely]] {
-      int thousands = line / 1000;
-      buffer[pos++] = '0' + thousands;
-      line -= thousands * 1000;
-    }
-    int hundreds = line / 100;
-    int remainder = line - hundreds * 100;
-    int tens = remainder / 10;
-    buffer[pos++] = '0' + hundreds;
-    buffer[pos++] = '0' + tens;
-    buffer[pos++] = '0' + (remainder - tens * 10);
-    buffer[pos++] = ']';
-
-#if defined(USE_ESP32) || defined(USE_LIBRETINY) || defined(USE_ZEPHYR) || defined(USE_HOST)
-    if (thread_name != nullptr) {
-      write_ansi_color_for_level(buffer, pos, 1);  // Always use bold red for thread name
-      buffer[pos++] = '[';
-      copy_string(buffer, pos, thread_name);
-      buffer[pos++] = ']';
-      write_ansi_color_for_level(buffer, pos, level);  // Restore original color
-    }
-#endif
-
-    buffer[pos++] = ':';
-    buffer[pos++] = ' ';
-    *buffer_at = pos;
-  }
-
-  // Helper to process vsnprintf return value and strip trailing newlines.
-  // Updates buffer_at with the formatted length, handling truncation:
-  // - When vsnprintf truncates (ret >= remaining), it writes (remaining - 1) chars + null terminator
-  // - When it doesn't truncate (ret < remaining), it writes ret chars + null terminator
-  __attribute__((always_inline)) static inline void process_vsnprintf_result(const char *buffer, uint16_t *buffer_at,
-                                                                             uint16_t remaining, int ret) {
-    if (ret < 0)
-      return;  // Encoding error, do not increment buffer_at
-    *buffer_at += (ret >= remaining) ? (remaining - 1) : static_cast<uint16_t>(ret);
-    // Remove all trailing newlines right after formatting
-    while (*buffer_at > 0 && buffer[*buffer_at - 1] == '\n')
-      (*buffer_at)--;
-  }
-
-  inline void HOT format_body_to_buffer_(char *buffer, uint16_t *buffer_at, uint16_t buffer_size, const char *format,
-                                         va_list args) {
-    // Check remaining capacity in the buffer
-    if (*buffer_at >= buffer_size)
-      return;
-    const uint16_t remaining = buffer_size - *buffer_at;
-    process_vsnprintf_result(buffer, buffer_at, remaining, vsnprintf(buffer + *buffer_at, remaining, format, args));
-  }
-
-#ifdef USE_STORE_LOG_STR_IN_FLASH
-  // ESP8266 variant that reads format string directly from flash using vsnprintf_P
-  inline void HOT format_body_to_buffer_P_(char *buffer, uint16_t *buffer_at, uint16_t buffer_size, PGM_P format,
-                                           va_list args) {
-    if (*buffer_at >= buffer_size)
-      return;
-    const uint16_t remaining = buffer_size - *buffer_at;
-    process_vsnprintf_result(buffer, buffer_at, remaining, vsnprintf_P(buffer + *buffer_at, remaining, format, args));
-  }
-#endif
-
-  inline void HOT write_footer_to_buffer_(char *buffer, uint16_t *buffer_at, uint16_t buffer_size) {
-    static constexpr uint16_t RESET_COLOR_LEN = sizeof(ESPHOME_LOG_RESET_COLOR) - 1;
-    this->write_body_to_buffer_(ESPHOME_LOG_RESET_COLOR, RESET_COLOR_LEN, buffer, buffer_at, buffer_size);
-  }
-
 #if defined(USE_ESP32) || defined(USE_LIBRETINY)
   // Disable loop when task buffer is empty (with USB CDC check on ESP32)
   inline void disable_loop_when_buffer_empty_() {

esphome/components/logger/logger_esp32.cpp

@@ -118,9 +118,7 @@ void Logger::pre_setup() {
   ESP_LOGI(TAG, "Log initialized");
 }
 
-void HOT Logger::write_msg_(const char *msg, size_t len) {
-  // Length is now always passed explicitly - no strlen() fallback needed
-
+void HOT Logger::write_msg_(const char *msg, uint16_t len) {
 #if defined(USE_LOGGER_UART_SELECTION_USB_CDC) || defined(USE_LOGGER_UART_SELECTION_USB_SERIAL_JTAG)
   // USB CDC/JTAG - single write including newline (already in buffer)
   // Use fwrite to stdout which goes through VFS to USB console

esphome/components/logger/logger_esp8266.cpp

@@ -28,7 +28,7 @@ void Logger::pre_setup() {
   ESP_LOGI(TAG, "Log initialized");
 }
 
-void HOT Logger::write_msg_(const char *msg, size_t len) {
+void HOT Logger::write_msg_(const char *msg, uint16_t len) {
   // Single write with newline already in buffer (added by caller)
   this->hw_serial_->write(msg, len);
 }

esphome/components/logger/logger_host.cpp

@@ -3,7 +3,7 @@
 
 namespace esphome::logger {
 
-void HOT Logger::write_msg_(const char *msg, size_t len) {
+void HOT Logger::write_msg_(const char *msg, uint16_t len) {
   static constexpr size_t TIMESTAMP_LEN = 10;  // "[HH:MM:SS]"
   // tx_buffer_size_ defaults to 512, so 768 covers default + headroom
   char buffer[TIMESTAMP_LEN + 768];
@@ -15,7 +15,7 @@ void HOT Logger::write_msg_(const char *msg, size_t len) {
   size_t pos = strftime(buffer, TIMESTAMP_LEN + 1, "[%H:%M:%S]", &timeinfo);
 
   // Copy message (with newline already included by caller)
-  size_t copy_len = std::min(len, sizeof(buffer) - pos);
+  size_t copy_len = std::min(static_cast<size_t>(len), sizeof(buffer) - pos);
   memcpy(buffer + pos, msg, copy_len);
   pos += copy_len;
 

esphome/components/logger/logger_libretiny.cpp

@@ -49,7 +49,7 @@ void Logger::pre_setup() {
   ESP_LOGI(TAG, "Log initialized");
 }
 
-void HOT Logger::write_msg_(const char *msg, size_t len) { this->hw_serial_->write(msg, len); }
+void HOT Logger::write_msg_(const char *msg, uint16_t len) { this->hw_serial_->write(msg, len); }
 
 const LogString *Logger::get_uart_selection_() {
   switch (this->uart_) {

esphome/components/logger/logger_rp2040.cpp

@@ -27,7 +27,7 @@ void Logger::pre_setup() {
   ESP_LOGI(TAG, "Log initialized");
 }
 
-void HOT Logger::write_msg_(const char *msg, size_t len) {
+void HOT Logger::write_msg_(const char *msg, uint16_t len) {
   // Single write with newline already in buffer (added by caller)
   this->hw_serial_->write(msg, len);
 }

esphome/components/logger/logger_zephyr.cpp

@@ -63,7 +63,7 @@ void Logger::pre_setup() {
   ESP_LOGI(TAG, "Log initialized");
 }
 
-void HOT Logger::write_msg_(const char *msg, size_t len) {
+void HOT Logger::write_msg_(const char *msg, uint16_t len) {
   // Single write with newline already in buffer (added by caller)
 #ifdef CONFIG_PRINTK
   // Requires the debug component and an active SWD connection.
@@ -73,7 +73,7 @@ void HOT Logger::write_msg_(const char *msg, size_t len) {
   if (this->uart_dev_ == nullptr) {
     return;
   }
-  for (size_t i = 0; i < len; ++i) {
+  for (uint16_t i = 0; i < len; ++i) {
     uart_poll_out(this->uart_dev_, msg[i]);
   }
 }