esphome 2025.4.2__py3-none-any.whl → 2025.5.0b3__py3-none-any.whl

esphome/components/ld2410/ld2410.h

@@ -129,7 +129,7 @@ enum PeriodicDataStructure : uint8_t {
   LIGHT_SENSOR = 37,
   OUT_PIN_SENSOR = 38,
 };
-enum PeriodicDataValue : uint8_t { HEAD = 0XAA, END = 0x55, CHECK = 0x00 };
+enum PeriodicDataValue : uint8_t { HEAD = 0xAA, END = 0x55, CHECK = 0x00 };
 
 enum AckDataStructure : uint8_t { COMMAND = 6, COMMAND_STATUS = 7 };
 

esphome/components/ld2450/ld2450.h

@@ -105,7 +105,7 @@ enum PeriodicDataStructure : uint8_t {
   TARGET_RESOLUTION = 10,
 };
 
-enum PeriodicDataValue : uint8_t { HEAD = 0XAA, END = 0x55, CHECK = 0x00 };
+enum PeriodicDataValue : uint8_t { HEAD = 0xAA, END = 0x55, CHECK = 0x00 };
 
 enum AckDataStructure : uint8_t { COMMAND = 6, COMMAND_STATUS = 7 };
 

esphome/components/light/__init__.py

@@ -1,3 +1,5 @@
+import enum
+
 import esphome.automation as auto
 import esphome.codegen as cg
 from esphome.components import mqtt, power_supply, web_server
@@ -13,15 +15,18 @@ from esphome.const import (
     CONF_COLOR_TEMPERATURE,
     CONF_DEFAULT_TRANSITION_LENGTH,
     CONF_EFFECTS,
+    CONF_ENTITY_CATEGORY,
     CONF_FLASH_TRANSITION_LENGTH,
     CONF_GAMMA_CORRECT,
     CONF_GREEN,
+    CONF_ICON,
     CONF_ID,
     CONF_INITIAL_STATE,
     CONF_MQTT_ID,
     CONF_ON_STATE,
     CONF_ON_TURN_OFF,
     CONF_ON_TURN_ON,
+    CONF_OUTPUT_ID,
     CONF_POWER_SUPPLY,
     CONF_RED,
     CONF_RESTORE_MODE,
@@ -33,6 +38,7 @@ from esphome.const import (
     CONF_WHITE,
 )
 from esphome.core import coroutine_with_priority
+from esphome.cpp_generator import MockObjClass
 from esphome.cpp_helpers import setup_entity
 
 from .automation import LIGHT_STATE_SCHEMA
@@ -141,6 +147,51 @@ ADDRESSABLE_LIGHT_SCHEMA = RGB_LIGHT_SCHEMA.extend(
 )
 
 
+class LightType(enum.IntEnum):
+    """Light type enum."""
+
+    BINARY = 0
+    BRIGHTNESS_ONLY = 1
+    RGB = 2
+    ADDRESSABLE = 3
+
+
+def light_schema(
+    class_: MockObjClass,
+    type_: LightType,
+    *,
+    entity_category: str = cv.UNDEFINED,
+    icon: str = cv.UNDEFINED,
+    default_restore_mode: str = cv.UNDEFINED,
+) -> cv.Schema:
+    schema = {
+        cv.GenerateID(CONF_OUTPUT_ID): cv.declare_id(class_),
+    }
+
+    for key, default, validator in [
+        (CONF_ENTITY_CATEGORY, entity_category, cv.entity_category),
+        (CONF_ICON, icon, cv.icon),
+        (
+            CONF_RESTORE_MODE,
+            default_restore_mode,
+            cv.enum(RESTORE_MODES, upper=True, space="_"),
+        ),
+    ]:
+        if default is not cv.UNDEFINED:
+            schema[cv.Optional(key, default=default)] = validator
+
+    if type_ == LightType.BINARY:
+        return BINARY_LIGHT_SCHEMA.extend(schema)
+    if type_ == LightType.BRIGHTNESS_ONLY:
+        return BRIGHTNESS_ONLY_LIGHT_SCHEMA.extend(schema)
+    if type_ == LightType.RGB:
+        return RGB_LIGHT_SCHEMA.extend(schema)
+    if type_ == LightType.ADDRESSABLE:
+        return ADDRESSABLE_LIGHT_SCHEMA.extend(schema)
+
+    raise ValueError(f"Invalid light type: {type_}")
+
+
 def validate_color_temperature_channels(value):
     if (
         CONF_COLD_WHITE_COLOR_TEMPERATURE in value
@@ -223,6 +274,12 @@ async def register_light(output_var, config):
     await setup_light_core_(light_var, output_var, config)
 
 
+async def new_light(config, *args):
+    output_var = cg.new_Pvariable(config[CONF_OUTPUT_ID], *args)
+    await register_light(output_var, config)
+    return output_var
+
+
 @coroutine_with_priority(100.0)
 async def to_code(config):
     cg.add_define("USE_LIGHT")

esphome/components/lock/__init__.py

@@ -4,6 +4,8 @@ import esphome.codegen as cg
 from esphome.components import mqtt, web_server
 import esphome.config_validation as cv
 from esphome.const import (
+    CONF_ENTITY_CATEGORY,
+    CONF_ICON,
     CONF_ID,
     CONF_MQTT_ID,
     CONF_ON_LOCK,
@@ -12,6 +14,7 @@ from esphome.const import (
     CONF_WEB_SERVER,
 )
 from esphome.core import CORE, coroutine_with_priority
+from esphome.cpp_generator import MockObjClass
 from esphome.cpp_helpers import setup_entity
 
 CODEOWNERS = ["@esphome/core"]
@@ -31,7 +34,19 @@ LockCondition = lock_ns.class_("LockCondition", Condition)
 LockLockTrigger = lock_ns.class_("LockLockTrigger", automation.Trigger.template())
 LockUnlockTrigger = lock_ns.class_("LockUnlockTrigger", automation.Trigger.template())
 
-LOCK_SCHEMA = (
+LockState = lock_ns.enum("LockState")
+
+LOCK_STATES = {
+    "LOCKED": LockState.LOCK_STATE_LOCKED,
+    "UNLOCKED": LockState.LOCK_STATE_UNLOCKED,
+    "JAMMED": LockState.LOCK_STATE_JAMMED,
+    "LOCKING": LockState.LOCK_STATE_LOCKING,
+    "UNLOCKING": LockState.LOCK_STATE_UNLOCKING,
+}
+
+validate_lock_state = cv.enum(LOCK_STATES, upper=True)
+
+_LOCK_SCHEMA = (
     cv.ENTITY_BASE_SCHEMA.extend(web_server.WEBSERVER_SORTING_SCHEMA)
     .extend(cv.MQTT_COMMAND_COMPONENT_SCHEMA)
     .extend(
@@ -52,7 +67,33 @@ LOCK_SCHEMA = (
 )
 
 
-async def setup_lock_core_(var, config):
+def lock_schema(
+    class_: MockObjClass = cv.UNDEFINED,
+    *,
+    icon: str = cv.UNDEFINED,
+    entity_category: str = cv.UNDEFINED,
+) -> cv.Schema:
+    schema = {}
+
+    if class_ is not cv.UNDEFINED:
+        schema[cv.GenerateID()] = cv.declare_id(class_)
+
+    for key, default, validator in [
+        (CONF_ICON, icon, cv.icon),
+        (CONF_ENTITY_CATEGORY, entity_category, cv.entity_category),
+    ]:
+        if default is not cv.UNDEFINED:
+            schema[cv.Optional(key, default=default)] = validator
+
+    return _LOCK_SCHEMA.extend(schema)
+
+
+# Remove before 2025.11.0
+LOCK_SCHEMA = lock_schema()
+LOCK_SCHEMA.add_extra(cv.deprecated_schema_constant("lock"))
+
+
+async def _setup_lock_core(var, config):
     await setup_entity(var, config)
 
     for conf in config.get(CONF_ON_LOCK, []):
@@ -74,12 +115,18 @@ async def register_lock(var, config):
     if not CORE.has_id(config[CONF_ID]):
         var = cg.Pvariable(config[CONF_ID], var)
     cg.add(cg.App.register_lock(var))
-    await setup_lock_core_(var, config)
+    await _setup_lock_core(var, config)
+
+
+async def new_lock(config, *args):
+    var = cg.new_Pvariable(config[CONF_ID], *args)
+    await register_lock(var, config)
+    return var
 
 
 LOCK_ACTION_SCHEMA = maybe_simple_id(
     {
-        cv.Required(CONF_ID): cv.use_id(Lock),
+        cv.GenerateID(CONF_ID): cv.use_id(Lock),
     }
 )
 

esphome/components/lock/automation.h

@@ -1,8 +1,8 @@
 #pragma once
 
-#include "esphome/core/component.h"
-#include "esphome/core/automation.h"
 #include "esphome/components/lock/lock.h"
+#include "esphome/core/automation.h"
+#include "esphome/core/component.h"
 
 namespace esphome {
 namespace lock {
@@ -72,16 +72,5 @@ class LockUnlockTrigger : public Trigger<> {
   }
 };
 
-template<typename... Ts> class LockPublishAction : public Action<Ts...> {
- public:
-  LockPublishAction(Lock *a_lock) : lock_(a_lock) {}
-  TEMPLATABLE_VALUE(LockState, state)
-
-  void play(Ts... x) override { this->lock_->publish_state(this->state_.value(x...)); }
-
- protected:
-  Lock *lock_;
-};
-
 }  // namespace lock
 }  // namespace esphome

esphome/components/logger/__init__.py

@@ -79,6 +79,7 @@ DEFAULT = "DEFAULT"
 
 CONF_INITIAL_LEVEL = "initial_level"
 CONF_LOGGER_ID = "logger_id"
+CONF_TASK_LOG_BUFFER_SIZE = "task_log_buffer_size"
 
 UART_SELECTION_ESP32 = {
     VARIANT_ESP32: [UART0, UART1, UART2],
@@ -180,6 +181,20 @@ CONFIG_SCHEMA = cv.All(
             cv.Optional(CONF_BAUD_RATE, default=115200): cv.positive_int,
             cv.Optional(CONF_TX_BUFFER_SIZE, default=512): cv.validate_bytes,
             cv.Optional(CONF_DEASSERT_RTS_DTR, default=False): cv.boolean,
+            cv.SplitDefault(
+                CONF_TASK_LOG_BUFFER_SIZE,
+                esp32=768,  # Default: 768 bytes (~5-6 messages with 70-byte text plus thread names)
+            ): cv.All(
+                cv.only_on_esp32,
+                cv.validate_bytes,
+                cv.Any(
+                    cv.int_(0),  # Disabled
+                    cv.int_range(
+                        min=640,  # Min: ~4-5 messages with 70-byte text plus thread names
+                        max=32768,  # Max: Depends on message sizes, typically ~300 messages with default size
+                    ),
+                ),
+            ),
             cv.SplitDefault(
                 CONF_HARDWARE_UART,
                 esp8266=UART0,
@@ -238,6 +253,13 @@ async def to_code(config):
         baud_rate,
         config[CONF_TX_BUFFER_SIZE],
     )
+    if CORE.is_esp32:
+        cg.add(log.create_pthread_key())
+        task_log_buffer_size = config[CONF_TASK_LOG_BUFFER_SIZE]
+        if task_log_buffer_size > 0:
+            cg.add_define("USE_ESPHOME_TASK_LOG_BUFFER")
+            cg.add(log.init_log_buffer(task_log_buffer_size))
+
     cg.add(log.set_log_level(initial_level))
     if CONF_HARDWARE_UART in config:
         cg.add(

esphome/components/logger/logger.cpp

@@ -1,5 +1,8 @@
 #include "logger.h"
 #include <cinttypes>
+#ifdef USE_ESPHOME_TASK_LOG_BUFFER
+#include <memory>  // For unique_ptr
+#endif
 
 #include "esphome/core/hal.h"
 #include "esphome/core/log.h"
@@ -10,127 +13,132 @@ namespace logger {
 
 static const char *const TAG = "logger";
 
-static const char *const LOG_LEVEL_COLORS[] = {
-    "",                                            // NONE
-    ESPHOME_LOG_BOLD(ESPHOME_LOG_COLOR_RED),       // ERROR
-    ESPHOME_LOG_COLOR(ESPHOME_LOG_COLOR_YELLOW),   // WARNING
-    ESPHOME_LOG_COLOR(ESPHOME_LOG_COLOR_GREEN),    // INFO
-    ESPHOME_LOG_COLOR(ESPHOME_LOG_COLOR_MAGENTA),  // CONFIG
-    ESPHOME_LOG_COLOR(ESPHOME_LOG_COLOR_CYAN),     // DEBUG
-    ESPHOME_LOG_COLOR(ESPHOME_LOG_COLOR_GRAY),     // VERBOSE
-    ESPHOME_LOG_COLOR(ESPHOME_LOG_COLOR_WHITE),    // VERY_VERBOSE
-};
-static const char *const LOG_LEVEL_LETTERS[] = {
-    "",    // NONE
-    "E",   // ERROR
-    "W",   // WARNING
-    "I",   // INFO
-    "C",   // CONFIG
-    "D",   // DEBUG
-    "V",   // VERBOSE
-    "VV",  // VERY_VERBOSE
-};
-
-void Logger::write_header_(int level, const char *tag, int line) {
-  if (level < 0)
-    level = 0;
-  if (level > 7)
-    level = 7;
-
-  const char *color = LOG_LEVEL_COLORS[level];
-  const char *letter = LOG_LEVEL_LETTERS[level];
-#if defined(USE_ESP32) || defined(USE_LIBRETINY)
+#ifdef USE_ESP32
+// Implementation for ESP32 (multi-task platform with task-specific tracking)
+// Main task always uses direct buffer access for console output and callbacks
+//
+// For non-main tasks:
+//  - WITH task log buffer: Prefer sending to ring buffer for async processing
+//    - Avoids allocating stack memory for console output in normal operation
+//    - Prevents console corruption from concurrent writes by multiple tasks
+//    - Messages are serialized through main loop for proper console output
+//    - Fallback to emergency console logging only if ring buffer is full
+//  - WITHOUT task log buffer: Only emergency console output, no callbacks
+void HOT Logger::log_vprintf_(int level, const char *tag, int line, const char *format, va_list args) {  // NOLINT
+  if (level > this->level_for(tag))
+    return;
+
   TaskHandle_t current_task = xTaskGetCurrentTaskHandle();
-#else
-  void *current_task = nullptr;
-#endif
-  if (current_task == main_task_) {
-    this->printf_to_buffer_("%s[%s][%s:%03u]: ", color, letter, tag, line);
-  } else {
-    const char *thread_name = "";  // NOLINT(clang-analyzer-deadcode.DeadStores)
-#if defined(USE_ESP32)
-    thread_name = pcTaskGetName(current_task);
-#elif defined(USE_LIBRETINY)
-    thread_name = pcTaskGetTaskName(current_task);
-#endif
-    this->printf_to_buffer_("%s[%s][%s:%03u]%s[%s]%s: ", color, letter, tag, line,
-                            ESPHOME_LOG_BOLD(ESPHOME_LOG_COLOR_RED), thread_name, color);
+  bool is_main_task = (current_task == main_task_);
+
+  // Check and set recursion guard - uses pthread TLS for per-task state
+  if (this->check_and_set_task_log_recursion_(is_main_task)) {
+    return;  // Recursion detected
   }
-}
 
+  // Main task uses the shared buffer for efficiency
+  if (is_main_task) {
+    this->log_message_to_buffer_and_send_(level, tag, line, format, args);
+    this->reset_task_log_recursion_(is_main_task);
+    return;
+  }
+
+  bool message_sent = false;
+#ifdef USE_ESPHOME_TASK_LOG_BUFFER
+  // For non-main tasks, queue the message for callbacks - but only if we have any callbacks registered
+  message_sent = this->log_buffer_->send_message_thread_safe(static_cast<uint8_t>(level), tag,
+                                                             static_cast<uint16_t>(line), current_task, format, args);
+#endif  // USE_ESPHOME_TASK_LOG_BUFFER
+
+  // Emergency console logging for non-main tasks when ring buffer is full or disabled
+  // This is a fallback mechanism to ensure critical log messages are visible
+  // Note: This may cause interleaved/corrupted console output if multiple tasks
+  // log simultaneously, but it's better than losing important messages entirely
+  if (!message_sent && this->baud_rate_ > 0) {  // If logging is enabled, write to console
+    // Maximum size for console log messages (includes null terminator)
+    static const size_t MAX_CONSOLE_LOG_MSG_SIZE = 144;
+    char console_buffer[MAX_CONSOLE_LOG_MSG_SIZE];  // MUST be stack allocated for thread safety
+    int 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);
+    this->write_msg_(console_buffer);
+  }
+
+  // Reset the recursion guard for this task
+  this->reset_task_log_recursion_(is_main_task);
+}
+#else
+// Implementation for all other platforms
 void HOT Logger::log_vprintf_(int level, const char *tag, int line, const char *format, va_list args) {  // NOLINT
-  if (level > this->level_for(tag) || recursion_guard_)
+  if (level > this->level_for(tag) || global_recursion_guard_)
     return;
 
-  recursion_guard_ = true;
-  this->reset_buffer_();
-  this->write_header_(level, tag, line);
-  this->vprintf_to_buffer_(format, args);
-  this->write_footer_();
-  this->log_message_(level, tag);
-  recursion_guard_ = false;
+  global_recursion_guard_ = true;
+
+  // Format and send to both console and callbacks
+  this->log_message_to_buffer_and_send_(level, tag, line, format, args);
+
+  global_recursion_guard_ = false;
 }
+#endif  // !USE_ESP32
+
 #ifdef USE_STORE_LOG_STR_IN_FLASH
+// Implementation for ESP8266 with flash string support.
+// Note: USE_STORE_LOG_STR_IN_FLASH is only defined for ESP8266.
 void Logger::log_vprintf_(int level, const char *tag, int line, const __FlashStringHelper *format,
                           va_list args) {  // NOLINT
-  if (level > this->level_for(tag) || recursion_guard_)
+  if (level > this->level_for(tag) || global_recursion_guard_)
     return;
 
-  recursion_guard_ = true;
-  this->reset_buffer_();
-  // copy format string
+  global_recursion_guard_ = true;
+  this->tx_buffer_at_ = 0;
+
+  // Copy format string from progmem
   auto *format_pgm_p = reinterpret_cast<const uint8_t *>(format);
-  size_t len = 0;
   char ch = '.';
-  while (!this->is_buffer_full_() && ch != '\0') {
+  while (this->tx_buffer_at_ < this->tx_buffer_size_ && ch != '\0') {
     this->tx_buffer_[this->tx_buffer_at_++] = ch = (char) progmem_read_byte(format_pgm_p++);
   }
-  // Buffer full form copying format
-  if (this->is_buffer_full_())
+
+  // Buffer full from copying format
+  if (this->tx_buffer_at_ >= this->tx_buffer_size_) {
+    global_recursion_guard_ = false;  // Make sure to reset the recursion guard before returning
     return;
+  }
+
+  // Save the offset before calling format_log_to_buffer_with_terminator_
+  // since it will increment tx_buffer_at_ to the end of the formatted string
+  uint32_t msg_start = this->tx_buffer_at_;
+  this->format_log_to_buffer_with_terminator_(level, tag, line, this->tx_buffer_, args, this->tx_buffer_,
+                                              &this->tx_buffer_at_, this->tx_buffer_size_);
 
-  // length of format string, includes null terminator
-  uint32_t offset = this->tx_buffer_at_;
+  // Write to console and send callback starting at the msg_start
+  if (this->baud_rate_ > 0) {
+    this->write_msg_(this->tx_buffer_ + msg_start);
+  }
+  this->call_log_callbacks_(level, tag, this->tx_buffer_ + msg_start);
 
-  // now apply vsnprintf
-  this->write_header_(level, tag, line);
-  this->vprintf_to_buffer_(this->tx_buffer_, args);
-  this->write_footer_();
-  this->log_message_(level, tag, offset);
-  recursion_guard_ = false;
+  global_recursion_guard_ = false;
 }
-#endif
+#endif  // USE_STORE_LOG_STR_IN_FLASH
 
-int HOT Logger::level_for(const char *tag) {
-  if (this->log_levels_.count(tag) != 0)
-    return this->log_levels_[tag];
+inline int Logger::level_for(const char *tag) {
+  auto it = this->log_levels_.find(tag);
+  if (it != this->log_levels_.end())
+    return it->second;
   return this->current_level_;
 }
 
-void HOT Logger::log_message_(int level, const char *tag, int offset) {
-  // remove trailing newline
-  if (this->tx_buffer_[this->tx_buffer_at_ - 1] == '\n') {
-    this->tx_buffer_at_--;
-  }
-  // make sure null terminator is present
-  this->set_null_terminator_();
-
-  const char *msg = this->tx_buffer_ + offset;
-
-  if (this->baud_rate_ > 0) {
-    this->write_msg_(msg);
-  }
-
+void HOT Logger::call_log_callbacks_(int level, const char *tag, const char *msg) {
 #ifdef USE_ESP32
-  // Suppress network-logging if memory constrained, but still log to serial
-  // ports. In some configurations (eg BLE enabled) there may be some transient
+  // Suppress network-logging if memory constrained
+  // In some configurations (eg BLE enabled) there may be some transient
   // memory exhaustion, and trying to log when OOM can lead to a crash. Skipping
   // here usually allows the stack to recover instead.
   // See issue #1234 for analysis.
   if (xPortGetFreeHeapSize() < 2048)
     return;
 #endif
-
   this->log_callback_.call(level, tag, msg);
 }
 
@@ -141,21 +149,60 @@ Logger::Logger(uint32_t baud_rate, size_t tx_buffer_size) : baud_rate_(baud_rate
   this->main_task_ = xTaskGetCurrentTaskHandle();
 #endif
 }
+#ifdef USE_ESPHOME_TASK_LOG_BUFFER
+void Logger::init_log_buffer(size_t total_buffer_size) {
+  this->log_buffer_ = esphome::make_unique<logger::TaskLogBuffer>(total_buffer_size);
+}
+#endif
 
-#ifdef USE_LOGGER_USB_CDC
+#if defined(USE_LOGGER_USB_CDC) || defined(USE_ESP32)
 void Logger::loop() {
-#ifdef USE_ARDUINO
-  if (this->uart_ != UART_SELECTION_USB_CDC) {
-    return;
+#if defined(USE_LOGGER_USB_CDC) && defined(USE_ARDUINO)
+  if (this->uart_ == UART_SELECTION_USB_CDC) {
+    static bool opened = false;
+    if (opened == Serial) {
+      return;
+    }
+    if (false == opened) {
+      App.schedule_dump_config();
+    }
+    opened = !opened;
   }
-  static bool opened = false;
-  if (opened == Serial) {
-    return;
-  }
-  if (false == opened) {
-    App.schedule_dump_config();
+#endif
+
+#ifdef USE_ESPHOME_TASK_LOG_BUFFER
+  // Process any buffered messages when available
+  if (this->log_buffer_->has_messages()) {
+    logger::TaskLogBuffer::LogMessage *message;
+    const char *text;
+    void *received_token;
+
+    // Process messages from the buffer
+    while (this->log_buffer_->borrow_message_main_loop(&message, &text, &received_token)) {
+      this->tx_buffer_at_ = 0;
+      // Use the thread name that was stored when the message was created
+      // This avoids potential crashes if the task no longer exists
+      const char *thread_name = message->thread_name[0] != '\0' ? message->thread_name : nullptr;
+      this->write_header_to_buffer_(message->level, message->tag, message->line, thread_name, this->tx_buffer_,
+                                    &this->tx_buffer_at_, this->tx_buffer_size_);
+      this->write_body_to_buffer_(text, message->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';
+      this->call_log_callbacks_(message->level, message->tag, this->tx_buffer_);
+      // At this point all the data we need from message has been transferred to the tx_buffer
+      // so we can release the message to allow other tasks to use it as soon as possible.
+      this->log_buffer_->release_message_main_loop(received_token);
+
+      // Write to console from the main loop to prevent corruption from concurrent writes
+      // This ensures all log messages appear on the console in a clean, serialized manner
+      // Note: Messages may appear slightly out of order due to async processing, but
+      // this is preferred over corrupted/interleaved console output
+      if (this->baud_rate_ > 0) {
+        this->write_msg_(this->tx_buffer_);
+      }
+    }
   }
-  opened = !opened;
 #endif
 }
 #endif
@@ -171,7 +218,7 @@ void Logger::add_on_log_callback(std::function<void(int, const char *, const cha
   this->log_callback_.add(std::move(callback));
 }
 float Logger::get_setup_priority() const { return setup_priority::BUS + 500.0f; }
-const char *const LOG_LEVELS[] = {"NONE", "ERROR", "WARN", "INFO", "CONFIG", "DEBUG", "VERBOSE", "VERY_VERBOSE"};
+static const char *const LOG_LEVELS[] = {"NONE", "ERROR", "WARN", "INFO", "CONFIG", "DEBUG", "VERBOSE", "VERY_VERBOSE"};
 
 void Logger::dump_config() {
   ESP_LOGCONFIG(TAG, "Logger:");
@@ -181,12 +228,16 @@ void Logger::dump_config() {
   ESP_LOGCONFIG(TAG, "  Log Baud Rate: %" PRIu32, this->baud_rate_);
   ESP_LOGCONFIG(TAG, "  Hardware UART: %s", get_uart_selection_());
 #endif
+#ifdef USE_ESPHOME_TASK_LOG_BUFFER
+  if (this->log_buffer_) {
+    ESP_LOGCONFIG(TAG, "  Task Log Buffer Size: %u", this->log_buffer_->size());
+  }
+#endif
 
   for (auto &it : this->log_levels_) {
     ESP_LOGCONFIG(TAG, "  Level for '%s': %s", it.first.c_str(), LOG_LEVELS[it.second]);
   }
 }
-void Logger::write_footer_() { this->write_to_buffer_(ESPHOME_LOG_RESET_COLOR, strlen(ESPHOME_LOG_RESET_COLOR)); }
 
 void Logger::set_log_level(int level) {
   if (level > ESPHOME_LOG_LEVEL) {