Add log filtering config options

Avoids the cost of forming Python strings for logs which will be ignored.

Author: cjdsellers

RELEASES.md

@@ -3,17 +3,18 @@
 Released on TBD (UTC).
 
 ### Enhancements
-None
+- Added `log_commands` config option for `ActorConfig`, `StrategyConfig`, `ExecAlgorithmConfig` for more efficient log filtering
 
 ### Breaking Changes
-None
+- Renamed `event_logging` config option to `log_events`
 
 ### Internal Improvements
 - Ported market order filling for OrderMatchingEngine in Rust (#2202), thanks @filipmacek
 
 ### Fixes
 - Fixed backtest start and end time validation assertion (#2203), thanks @davidsblom
 - Fixed `CustomData` import in `DataEngine` (#2207), thanks @graceyangfan and @faysou
+- Fixed databento helper function (#2208), thanks @faysou
 
 ### Documentation Updates
 None

nautilus_trader/common/actor.pxd

@@ -51,6 +51,8 @@ from nautilus_trader.portfolio.base cimport PortfolioFacade
 
 cdef class Actor(Component):
     cdef object _executor
+    cdef bint _log_events
+    cdef bint _log_commands
     cdef set[type] _warning_events
     cdef dict[UUID4, object] _pending_requests
     cdef set[type] _pyo3_conversion_types

nautilus_trader/common/actor.pyx

@@ -130,6 +130,8 @@ cdef class Actor(Component):
         self._indicators_for_bars: dict[BarType, list[Indicator]] = {}
 
         # Configuration
+        self._log_events = config.log_events
+        self._log_commands = config.log_commands
         self.config = config
 
         self.trader_id = None  # Initialized when registered
@@ -3290,7 +3292,7 @@ cdef class Actor(Component):
 # -- EGRESS ---------------------------------------------------------------------------------------
 
     cdef void _send_data_cmd(self, DataCommand command):
-        if is_logging_initialized():
+        if self._log_commands and is_logging_initialized():
             self._log.info(f"{CMD}{SENT} {command}")
         self._msgbus.send(endpoint="DataEngine.execute", msg=command)
 

nautilus_trader/common/config.py

@@ -415,10 +415,17 @@ class ActorConfig(NautilusConfig, kw_only=True, frozen=True):
     component_id : ComponentId, optional
         The component ID. If ``None`` then the identifier will be taken from
         `type(self).__name__`.
+    log_events : bool, default True
+        If events should be logged by the actor.
+        If False, then only warning events and above are logged.
+    log_commands : bool, default True
+        If commands should be logged by the actor.
 
     """
 
     component_id: ComponentId | None = None
+    log_events: bool = True
+    log_commands: bool = True
 
 
 class ImportableActorConfig(NautilusConfig, frozen=True):

nautilus_trader/execution/algorithm.pyx

@@ -25,7 +25,6 @@ from libc.stdint cimport uint64_t
 from nautilus_trader.cache.base cimport CacheFacade
 from nautilus_trader.common.actor cimport Actor
 from nautilus_trader.common.component cimport CMD
-from nautilus_trader.common.component cimport EVT
 from nautilus_trader.common.component cimport RECV
 from nautilus_trader.common.component cimport SENT
 from nautilus_trader.common.component cimport Clock
@@ -118,6 +117,8 @@ cdef class ExecAlgorithm(Actor):
             self.id = config.exec_algorithm_id or ExecAlgorithmId(type(self).__name__)
 
         # Configuration
+        self._log_events = config.log_events
+        self._log_commands = config.log_commands
         self.config = config
 
         self._exec_spawn_ids: dict[ClientOrderId, int] = {}
@@ -253,7 +254,8 @@ cdef class ExecAlgorithm(Actor):
         """
         Condition.not_none(command, "command")
 
-        self._log.debug(f"{RECV}{CMD} {command}", LogColor.MAGENTA)
+        if self._log_commands:
+            self._log.debug(f"{RECV}{CMD} {command}", LogColor.MAGENTA)
 
         if self._fsm.state != ComponentState.RUNNING:
             return
@@ -1460,16 +1462,16 @@ cdef class ExecAlgorithm(Actor):
 # -- EGRESS ---------------------------------------------------------------------------------------
 
     cdef void _send_emulator_command(self, TradingCommand command):
-        if is_logging_initialized():
+        if self._log_commands and is_logging_initialized():
             self.log.info(f"{CMD}{SENT} {command}.")
         self._msgbus.send(endpoint="OrderEmulator.execute", msg=command)
 
     cdef void _send_risk_command(self, TradingCommand command):
-        if is_logging_initialized():
+        if self._log_commands and is_logging_initialized():
             self.log.info(f"{CMD}{SENT} {command}.")
         self._msgbus.send(endpoint="RiskEngine.execute", msg=command)
 
     cdef void _send_exec_command(self, TradingCommand command):
-        if is_logging_initialized():
+        if self._log_commands and is_logging_initialized():
             self.log.info(f"{CMD}{SENT} {command}.")
         self._msgbus.send(endpoint="ExecEngine.execute", msg=command)

nautilus_trader/execution/config.py

@@ -71,10 +71,17 @@ class ExecAlgorithmConfig(NautilusConfig, kw_only=True, frozen=True):
     exec_algorithm_id : ExecAlgorithmId, optional
         The unique ID for the execution algorithm.
         If not ``None`` then will become the execution algorithm ID.
+    log_events : bool, default True
+        If events should be logged by the execution algorithm.
+        If False, then only warning events and above are logged.
+    log_commands : bool, default True
+        If commands should be logged by the execution algorithm.
 
     """
 
     exec_algorithm_id: ExecAlgorithmId | None = None
+    log_events: bool = True
+    log_commands: bool = True
 
 
 class ImportableExecAlgorithmConfig(NautilusConfig, frozen=True):

nautilus_trader/execution/manager.pxd

@@ -51,6 +51,8 @@ cdef class OrderManager:
 
     cdef readonly bint active_local
     cdef readonly bint debug
+    cdef readonly bint log_events
+    cdef readonly bint log_commands
 
     cdef dict _submit_order_commands
     cdef object _submit_order_handler

nautilus_trader/execution/manager.pyx

@@ -19,7 +19,6 @@ from libc.stdint cimport uint64_t
 from nautilus_trader.cache.cache cimport Cache
 from nautilus_trader.common.component cimport CMD
 from nautilus_trader.common.component cimport EVT
-from nautilus_trader.common.component cimport RECV
 from nautilus_trader.common.component cimport SENT
 from nautilus_trader.common.component cimport Clock
 from nautilus_trader.common.component cimport LogColor
@@ -101,6 +100,8 @@ cdef class OrderManager:
         cancel_order_handler: Callable[[Order], None] = None,
         modify_order_handler: Callable[[Order, Quantity], None] = None,
         bint debug = False,
+        bint log_events = True,
+        bint log_commands = True,
     ):
         Condition.valid_string(component_name, "component_name")
         Condition.callable_or_none(submit_order_handler, "submit_order_handler")
@@ -114,6 +115,8 @@ cdef class OrderManager:
 
         self.active_local = active_local
         self.debug = debug
+        self.log_events = log_events
+        self.log_commands = log_commands
         self._submit_order_handler = submit_order_handler
         self._cancel_order_handler = cancel_order_handler
         self._modify_order_handler = modify_order_handler
@@ -554,42 +557,42 @@ cdef class OrderManager:
     cpdef void send_emulator_command(self, TradingCommand command):
         Condition.not_none(command, "command")
 
-        if is_logging_initialized():
+        if self.log_commands and is_logging_initialized():
             self._log.info(f"{CMD}{SENT} {command}")  # pragma: no cover  (no logging in tests)
         self._msgbus.send(endpoint="OrderEmulator.execute", msg=command)
 
     cpdef void send_algo_command(self, TradingCommand command, ExecAlgorithmId exec_algorithm_id):
         Condition.not_none(command, "command")
         Condition.not_none(exec_algorithm_id, "exec_algorithm_id")
 
-        if is_logging_initialized():
+        if self.log_commands and is_logging_initialized():
             self._log.info(f"{CMD}{SENT} {command}")  # pragma: no cover  (no logging in tests)
         self._msgbus.send(endpoint=f"{exec_algorithm_id}.execute", msg=command)
 
     cpdef void send_risk_command(self, TradingCommand command):
         Condition.not_none(command, "command")
 
-        if is_logging_initialized():
+        if self.log_commands and is_logging_initialized():
             self._log.info(f"{CMD}{SENT} {command}")  # pragma: no cover  (no logging in tests)
         self._msgbus.send(endpoint="RiskEngine.execute", msg=command)
 
     cpdef void send_exec_command(self, TradingCommand command):
         Condition.not_none(command, "command")
 
-        if is_logging_initialized():
+        if self.log_commands and is_logging_initialized():
             self._log.info(f"{CMD}{SENT} {command}")  # pragma: no cover  (no logging in tests)
         self._msgbus.send(endpoint="ExecEngine.execute", msg=command)
 
     cpdef void send_risk_event(self, OrderEvent event):
         Condition.not_none(event, "event")
 
-        if is_logging_initialized():
+        if self.log_events and is_logging_initialized():
             self._log.info(f"{EVT}{SENT} {event}")  # pragma: no cover  (no logging in tests)
         self._msgbus.send(endpoint="RiskEngine.process", msg=event)
 
     cpdef void send_exec_event(self, OrderEvent event):
         Condition.not_none(event, "event")
 
-        if is_logging_initialized():
+        if self.log_events and is_logging_initialized():
             self._log.info(f"{EVT}{SENT} {event}")  # pragma: no cover (no logging in tests)
         self._msgbus.send(endpoint="ExecEngine.process", msg=event)

nautilus_trader/trading/config.py

@@ -51,9 +51,11 @@ class StrategyConfig(NautilusConfig, kw_only=True, frozen=True):
     manage_gtd_expiry : bool, default False
         If all order GTD time in force expirations should be managed by the strategy.
         If True, then will ensure open orders have their GTD timers re-activated on start.
-    event_logging : bool, default True
-        If event logging should be enabled for the strategy.
+    log_events : bool, default True
+        If events should be logged by the strategy.
         If False, then only warning events and above are logged.
+    log_commands : bool, default True
+        If commands should be logged by the strategy.
 
     """
 
@@ -63,7 +65,8 @@ class StrategyConfig(NautilusConfig, kw_only=True, frozen=True):
     external_order_claims: list[InstrumentId] | None = None
     manage_contingent_orders: bool = False
     manage_gtd_expiry: bool = False
-    event_logging: bool = True
+    log_events: bool = True
+    log_commands: bool = True
 
 
 class ImportableStrategyConfig(NautilusConfig, frozen=True):

nautilus_trader/trading/strategy.pxd

@@ -81,8 +81,6 @@ cdef class Strategy(Actor):
     """If contingent orders should be managed automatically by the strategy.\n\n:returns: `bool`"""
     cdef readonly bint manage_gtd_expiry
     """If all order GTD time in force expirations should be managed automatically by the strategy.\n\n:returns: `bool`"""
-    cdef readonly bint event_logging
-    """If event logging should be enabled for the strategy.\n\n:returns: `bool`"""
 
 # -- REGISTRATION ---------------------------------------------------------------------------------