Improve databento crate feature flagging

Author: cjdsellers

Cargo.lock

@@ -18,12 +18,13 @@ name = "nautilus_databento"
 crate-type = ["rlib", "cdylib"]
 
 [features]
-default = []
+default = ["live"]
 extension-module = [
   "pyo3/extension-module",
   "nautilus-core/extension-module",
   "nautilus-model/extension-module",
 ]
+live = ["nautilus-live", "nautilus-system", "dotenvy", "tracing-subscriber", "pyo3"]
 python = [
   "pyo3",
   "pyo3-async-runtimes",
@@ -40,11 +41,14 @@ rustdoc-args = ["--cfg", "docsrs"]
 nautilus-common = { workspace = true }
 nautilus-core = { workspace = true, features = ["python"] }
 nautilus-data = { workspace = true }
+nautilus-live = { workspace = true, optional = true }
 nautilus-model = { workspace = true }
+nautilus-system = { workspace = true, optional = true }
 
 ahash = { workspace = true }
 anyhow = { workspace = true }
 async-trait = { workspace = true }
+dotenvy = { workspace = true, optional = true }
 indexmap = { workspace = true }
 itoa = { workspace = true }
 log = { workspace = true }
@@ -55,6 +59,7 @@ serde_json = { workspace = true }
 strum = { workspace = true }
 tokio = { workspace = true }
 tracing = { workspace = true }
+tracing-subscriber = { workspace = true, optional = true }
 ustr = { workspace = true }
 databento = "0.26.0"
 fallible-streaming-iterator = "0.1.9"
@@ -65,9 +70,13 @@ nautilus-testkit = { workspace = true }
 criterion = { workspace = true }
 rstest = { workspace = true }
 tracing-test = { workspace = true }
-tracing-subscriber = { workspace = true }
 
 [[bin]]
 name = "databento-sandbox"
 path = "bin/sandbox.rs"
 required-features = ["python"]
+
+[[bin]]
+name = "databento-node-test"
+path = "bin/node_test.rs"
+required-features = ["live"]

crates/adapters/databento/Cargo.toml

@@ -0,0 +1,97 @@
+// -------------------------------------------------------------------------------------------------
+//  Copyright (C) 2015-2025 Nautech Systems Pty Ltd. All rights reserved.
+//  https://nautechsystems.io
+//
+//  Licensed under the GNU Lesser General Public License Version 3.0 (the "License");
+//  You may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at https://www.gnu.org/licenses/lgpl-3.0.en.html
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+// -------------------------------------------------------------------------------------------------
+
+use std::path::PathBuf;
+
+use nautilus_common::enums::Environment;
+use nautilus_core::env::get_env_var;
+use nautilus_databento::factories::{DatabentoDataClientFactory, DatabentoLiveClientConfig};
+use nautilus_live::node::LiveNode;
+use nautilus_model::identifiers::TraderId;
+use tokio::time::Duration;
+
+// Run with `cargo run -p nautilus-databento --bin databento-node-test --features live`
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // TODO: Initialize Python interpreter only if python feature is enabled
+    // #[cfg(feature = "python")]
+    pyo3::prepare_freethreaded_python();
+
+    tracing_subscriber::fmt()
+        .with_max_level(tracing::Level::INFO)
+        .init();
+
+    dotenvy::dotenv().ok();
+
+    let environment = Environment::Live;
+    let trader_id = TraderId::default();
+    let node_name = "DATABENTO-TESTER-001".to_string();
+
+    // Get Databento API key from environment
+    let api_key = get_env_var("DATABENTO_API_KEY").unwrap_or_else(|_| {
+        println!("⚠️  DATABENTO_API_KEY not found, using placeholder");
+        "db-placeholder-key".to_string()
+    });
+
+    // Determine publishers file path
+    let publishers_filepath = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("publishers.json");
+    if !publishers_filepath.exists() {
+        println!(
+            "⚠️  Publishers file not found at: {}",
+            publishers_filepath.display()
+        );
+        println!("   This is expected in CI/test environments");
+    }
+
+    // Configure Databento client
+    let databento_config = DatabentoLiveClientConfig::new(
+        api_key,
+        publishers_filepath,
+        true, // use_exchange_as_venue
+        true, // bars_timestamp_on_close
+    );
+
+    let client_factory = Box::new(DatabentoDataClientFactory::new());
+
+    // Build the live node with Databento data client
+    let mut node = LiveNode::builder(node_name, trader_id, environment)?
+        .with_load_state(false)
+        .with_save_state(false)
+        .add_data_client(
+            Some("DATABENTO".to_string()), // Use custom name
+            client_factory,
+            Box::new(databento_config),
+        )?
+        .build()?;
+
+    node.start().await?;
+
+    // Let it run briefly to ensure all components are properly initialized
+    tokio::time::sleep(Duration::from_millis(100)).await;
+
+    node.stop().await?;
+
+    Ok(())
+}
+
+#[cfg(not(feature = "live"))]
+fn main() {
+    println!("⚠️  databento-node-test binary requires the 'live' feature to be enabled.");
+    println!(
+        "   Run with: cargo run -p nautilus-databento --bin databento-node-test --features live"
+    );
+    std::process::exit(1);
+}

crates/adapters/databento/bin/node_test.rs

@@ -15,22 +15,67 @@
 
 //! Factory functions for creating Databento clients and components.
 
-use std::path::PathBuf;
+use std::{any::Any, cell::RefCell, path::PathBuf, rc::Rc};
 
-use nautilus_core::time::AtomicTime;
+use nautilus_common::{cache::Cache, clock::Clock};
+use nautilus_core::time::{AtomicTime, get_atomic_clock_realtime};
+use nautilus_data::client::DataClient;
 use nautilus_model::identifiers::ClientId;
+use nautilus_system::factories::{ClientConfig, DataClientFactory};
 
 use crate::{
     data::{DatabentoDataClient, DatabentoDataClientConfig},
     historical::DatabentoHistoricalClient,
 };
 
+/// Configuration for Databento data clients used with `LiveNode`.
+#[derive(Debug, Clone)]
+pub struct DatabentoLiveClientConfig {
+    /// Databento API key.
+    pub api_key: String,
+    /// Path to publishers.json file.
+    pub publishers_filepath: PathBuf,
+    /// Whether to use exchange as venue for GLBX instruments.
+    pub use_exchange_as_venue: bool,
+    /// Whether to timestamp bars on close.
+    pub bars_timestamp_on_close: bool,
+}
+
+impl DatabentoLiveClientConfig {
+    /// Creates a new [`DatabentoLiveClientConfig`] instance.
+    #[must_use]
+    pub const fn new(
+        api_key: String,
+        publishers_filepath: PathBuf,
+        use_exchange_as_venue: bool,
+        bars_timestamp_on_close: bool,
+    ) -> Self {
+        Self {
+            api_key,
+            publishers_filepath,
+            use_exchange_as_venue,
+            bars_timestamp_on_close,
+        }
+    }
+}
+
+impl ClientConfig for DatabentoLiveClientConfig {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+}
+
 /// Factory for creating Databento data clients.
-#[cfg_attr(feature = "python", pyo3::pyclass)]
 #[derive(Debug)]
 pub struct DatabentoDataClientFactory;
 
 impl DatabentoDataClientFactory {
+    /// Creates a new [`DatabentoDataClientFactory`] instance.
+    #[must_use]
+    pub const fn new() -> Self {
+        Self
+    }
+
     /// Creates a new [`DatabentoDataClient`] instance.
     ///
     /// # Errors
@@ -68,20 +113,58 @@ impl DatabentoDataClientFactory {
     }
 }
 
+impl Default for DatabentoDataClientFactory {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl DataClientFactory for DatabentoDataClientFactory {
+    fn create(
+        &self,
+        name: &str,
+        config: &dyn ClientConfig,
+        _cache: Rc<RefCell<Cache>>,
+        _clock: Rc<RefCell<dyn Clock>>,
+    ) -> anyhow::Result<Box<dyn DataClient>> {
+        let databento_config = config
+            .as_any()
+            .downcast_ref::<DatabentoLiveClientConfig>()
+            .ok_or_else(|| {
+                anyhow::anyhow!(
+                    "Invalid config type for DatabentoDataClientFactory. Expected DatabentoLiveClientConfig, got {:?}",
+                    config
+                )
+            })?;
+
+        let client_id = ClientId::from(name);
+        let config = DatabentoDataClientConfig::new(
+            databento_config.api_key.clone(),
+            databento_config.publishers_filepath.clone(),
+            databento_config.use_exchange_as_venue,
+            databento_config.bars_timestamp_on_close,
+        );
+
+        let client = DatabentoDataClient::new(client_id, config, get_atomic_clock_realtime())?;
+        Ok(Box::new(client))
+    }
+
+    fn name(&self) -> &'static str {
+        "DATABENTO"
+    }
+
+    fn config_type(&self) -> &'static str {
+        "DatabentoLiveClientConfig"
+    }
+}
+
 /// Factory for creating Databento historical clients.
 #[derive(Debug)]
 pub struct DatabentoHistoricalClientFactory;
 
 impl DatabentoHistoricalClientFactory {
     /// Creates a new [`DatabentoHistoricalClient`] instance.
     ///
-    /// # Arguments
-    ///
-    /// * `api_key` - Databento API key for authentication
-    /// * `publishers_filepath` - Path to the publishers.json configuration file
-    /// * `use_exchange_as_venue` - Whether to use exchange codes as venues for GLBX instruments
-    /// * `clock` - Atomic clock for timestamping
-    ///
     /// # Errors
     ///
     /// Returns an error if the client cannot be created or publisher configuration cannot be loaded.

crates/adapters/databento/src/factories.rs

@@ -38,15 +38,21 @@
 #![deny(rustdoc::broken_intra_doc_links)]
 
 pub mod common;
-pub mod data;
 pub mod decode;
 pub mod enums;
-pub mod factories;
 pub mod historical;
-pub mod live;
 pub mod loader;
 pub mod symbology;
 pub mod types;
 
 #[cfg(feature = "python")]
 pub mod python;
+
+#[cfg(feature = "live")]
+pub mod data;
+
+#[cfg(feature = "live")]
+pub mod factories;
+
+#[cfg(feature = "live")]
+pub mod live;

crates/adapters/databento/src/lib.rs

@@ -17,10 +17,12 @@
 
 pub mod enums;
 pub mod historical;
-pub mod live;
 pub mod loader;
 pub mod types;
 
+#[cfg(feature = "live")]
+pub mod live;
+
 use pyo3::prelude::*;
 
 /// Loaded as `nautilus_pyo3.databento`
@@ -36,7 +38,9 @@ pub fn databento(_: Python<'_>, m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_class::<super::types::DatabentoStatistics>()?;
     m.add_class::<super::types::DatabentoImbalance>()?;
     m.add_class::<super::loader::DatabentoDataLoader>()?;
-    m.add_class::<live::DatabentoLiveClient>()?;
     m.add_class::<historical::DatabentoHistoricalClient>()?;
+
+    #[cfg(feature = "live")]
+    m.add_class::<live::DatabentoLiveClient>()?;
     Ok(())
 }