itsi 0.1.0

data/crates/itsi_server/src/server/listener.rs

@@ -0,0 +1,218 @@
+use super::bind::{Bind, BindAddress};
+use super::transfer_protocol::TransferProtocol;
+use hyper_util::rt::TokioIo;
+use itsi_error::Result;
+use itsi_tracing::info;
+use socket2::{Domain, Protocol, Socket, Type};
+use std::net::{IpAddr, SocketAddr, TcpListener as StdTcpListener};
+use std::pin::Pin;
+use std::sync::Arc;
+use std::{os::unix::net::UnixListener as StdUnixListener, path::PathBuf};
+use tokio::net::{unix, TcpListener, TcpStream, UnixListener, UnixStream};
+use tokio_rustls::TlsAcceptor;
+
+pub(crate) trait IoStream:
+    tokio::io::AsyncRead + tokio::io::AsyncWrite + Send + Unpin
+{
+}
+impl<T: tokio::io::AsyncRead + tokio::io::AsyncWrite + Send + Unpin> IoStream for T {}
+
+pub(crate) enum Listener {
+    Tcp(TcpListener),
+    TcpTls((TcpListener, TlsAcceptor)),
+    Unix(UnixListener),
+    UnixTls((UnixListener, TlsAcceptor)),
+}
+
+enum Stream {
+    TcpStream((TcpStream, SocketAddr)),
+    UnixStream((UnixStream, unix::SocketAddr)),
+}
+
+#[derive(Clone, Debug)]
+pub enum SockAddr {
+    Tcp(Arc<SocketAddr>),
+    Unix(Arc<unix::SocketAddr>),
+}
+impl std::fmt::Display for SockAddr {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            SockAddr::Tcp(socket_addr) => write!(f, "{}", socket_addr.ip().to_canonical()),
+            SockAddr::Unix(socket_addr) => match socket_addr.as_pathname() {
+                Some(path) => write!(f, "{:?}", path),
+                None => write!(f, ""),
+            },
+        }
+    }
+}
+
+impl Listener {
+    pub(crate) async fn accept(&self) -> Result<(TokioIo<Pin<Box<dyn IoStream>>>, SockAddr)> {
+        match self {
+            Listener::Tcp(listener) => Listener::accept_tcp(listener).await,
+            Listener::TcpTls((listener, acceptor)) => {
+                Listener::accept_tls(listener, acceptor).await
+            }
+            Listener::Unix(stream) => Listener::accept_unix(stream).await,
+            Listener::UnixTls((listener, acceptor)) => {
+                Listener::accept_unix_tls(listener, acceptor).await
+            }
+        }
+    }
+
+    async fn to_tokio_io(
+        input_stream: Stream,
+        tls_acceptor: Option<&TlsAcceptor>,
+    ) -> Result<(TokioIo<Pin<Box<dyn IoStream>>>, SockAddr)> {
+        match tls_acceptor {
+            Some(acceptor) => match input_stream {
+                Stream::TcpStream((tcp_stream, socket_address)) => {
+                    match acceptor.accept(tcp_stream).await {
+                        Ok(tls_stream) => Ok((
+                            TokioIo::new(Box::pin(tls_stream) as Pin<Box<dyn IoStream>>),
+                            SockAddr::Tcp(Arc::new(socket_address)),
+                        )),
+                        Err(err) => Err(err.into()),
+                    }
+                }
+                Stream::UnixStream((unix_stream, socket_address)) => {
+                    match acceptor.accept(unix_stream).await {
+                        Ok(tls_stream) => Ok((
+                            TokioIo::new(Box::pin(tls_stream) as Pin<Box<dyn IoStream>>),
+                            SockAddr::Unix(Arc::new(socket_address)),
+                        )),
+                        Err(err) => Err(err.into()),
+                    }
+                }
+            },
+            None => match input_stream {
+                Stream::TcpStream((tcp_stream, socket_address)) => Ok((
+                    TokioIo::new(Box::pin(tcp_stream) as Pin<Box<dyn IoStream>>),
+                    SockAddr::Tcp(Arc::new(socket_address)),
+                )),
+                Stream::UnixStream((unix_stream, socket_address)) => Ok((
+                    TokioIo::new(Box::pin(unix_stream) as Pin<Box<dyn IoStream>>),
+                    SockAddr::Unix(Arc::new(socket_address)),
+                )),
+            },
+        }
+    }
+
+    async fn accept_tcp(
+        listener: &TcpListener,
+    ) -> Result<(TokioIo<Pin<Box<dyn IoStream>>>, SockAddr)> {
+        let tcp_stream = listener.accept().await?;
+        Self::to_tokio_io(Stream::TcpStream(tcp_stream), None).await
+    }
+
+    async fn accept_tls(
+        listener: &TcpListener,
+        acceptor: &TlsAcceptor,
+    ) -> Result<(TokioIo<Pin<Box<dyn IoStream>>>, SockAddr)> {
+        let tcp_stream = listener.accept().await?;
+        Self::to_tokio_io(Stream::TcpStream(tcp_stream), Some(acceptor)).await
+    }
+
+    async fn accept_unix(
+        listener: &UnixListener,
+    ) -> Result<(TokioIo<Pin<Box<dyn IoStream>>>, SockAddr)> {
+        let unix_stream = listener.accept().await?;
+        Self::to_tokio_io(Stream::UnixStream(unix_stream), None).await
+    }
+
+    async fn accept_unix_tls(
+        listener: &UnixListener,
+        acceptor: &TlsAcceptor,
+    ) -> Result<(TokioIo<Pin<Box<dyn IoStream>>>, SockAddr)> {
+        let unix_stream = listener.accept().await?;
+        Self::to_tokio_io(Stream::UnixStream(unix_stream), Some(acceptor)).await
+    }
+
+    pub(crate) fn scheme(&self) -> String {
+        match self {
+            Listener::Tcp(_) => "http".to_string(),
+            Listener::TcpTls(_) => "https".to_string(),
+            Listener::Unix(_) => "http".to_string(),
+            Listener::UnixTls(_) => "https".to_string(),
+        }
+    }
+
+    pub(crate) fn port(&self) -> u16 {
+        match self {
+            Listener::Tcp(listener) => listener.local_addr().unwrap().port(),
+            Listener::TcpTls((listener, _)) => listener.local_addr().unwrap().port(),
+            Listener::Unix(_) => 0,
+            Listener::UnixTls(_) => 0,
+        }
+    }
+
+    pub(crate) fn host(&self) -> String {
+        match self {
+            Listener::Tcp(listener) => listener.local_addr().unwrap().ip().to_string(),
+            Listener::TcpTls((listener, _)) => listener.local_addr().unwrap().ip().to_string(),
+            Listener::Unix(_) => "unix".to_string(),
+            Listener::UnixTls(_) => "unix".to_string(),
+        }
+    }
+}
+
+impl From<Bind> for Listener {
+    fn from(bind: Bind) -> Self {
+        match bind.address {
+            BindAddress::Ip(addr) => match bind.protocol {
+                TransferProtocol::Http => Listener::Tcp(
+                    TcpListener::from_std(connect_tcp_socket(addr, bind.port.unwrap())).unwrap(),
+                ),
+                TransferProtocol::Https => {
+                    let tcp_listener =
+                        TcpListener::from_std(connect_tcp_socket(addr, bind.port.unwrap()))
+                            .unwrap();
+                    let tls_acceptor = TlsAcceptor::from(Arc::new(bind.tls_config.unwrap()));
+                    Listener::TcpTls((tcp_listener, tls_acceptor))
+                }
+                _ => unreachable!(),
+            },
+            BindAddress::UnixSocket(path) => match bind.tls_config {
+                Some(tls_config) => {
+                    let tls_acceptor = TlsAcceptor::from(Arc::new(tls_config));
+                    Listener::UnixTls((
+                        UnixListener::from_std(connect_unix_socket(&path)).unwrap(),
+                        tls_acceptor,
+                    ))
+                }
+                None => Listener::Unix(UnixListener::from_std(connect_unix_socket(&path)).unwrap()),
+            },
+        }
+    }
+}
+
+fn connect_tcp_socket(addr: IpAddr, port: u16) -> StdTcpListener {
+    let domain = match addr {
+        IpAddr::V4(_) => Domain::IPV4,
+        IpAddr::V6(_) => Domain::IPV6,
+    };
+    let socket = Socket::new(domain, Type::STREAM, Some(Protocol::TCP)).unwrap();
+    let socket_address: SocketAddr = SocketAddr::new(addr, port);
+    socket.set_reuse_address(true).ok();
+    socket.set_reuse_port(true).ok();
+    socket.set_nonblocking(true).ok();
+    socket.set_nodelay(true).ok();
+    socket.set_recv_buffer_size(1_048_576).ok();
+    info!("Binding to {}", socket_address);
+    socket.bind(&socket_address.into()).unwrap();
+    socket.listen(1024).unwrap();
+    socket.into()
+}
+
+fn connect_unix_socket(path: &PathBuf) -> StdUnixListener {
+    let _ = std::fs::remove_file(path);
+    let socket = Socket::new(Domain::UNIX, Type::STREAM, None).unwrap();
+    socket.set_nonblocking(true).ok();
+    let socket_address = socket2::SockAddr::unix(path).unwrap();
+
+    info!("Binding to {:?}", path);
+    socket.bind(&socket_address).unwrap();
+    socket.listen(1024).unwrap();
+
+    socket.into()
+}

data/crates/itsi_server/src/server/mod.rs

@@ -0,0 +1,5 @@
+pub mod bind;
+pub mod itsi_server;
+pub mod listener;
+pub mod tls;
+pub mod transfer_protocol;

data/crates/itsi_server/src/server/tls.rs

@@ -0,0 +1,138 @@
+use base64::{engine::general_purpose, Engine as _};
+use itsi_error::Result;
+use itsi_tracing::{info, warn};
+use rcgen::{CertificateParams, DnType, KeyPair, SanType};
+use rustls_pemfile::{certs, pkcs8_private_keys};
+use std::{collections::HashMap, fs, io::BufReader};
+use tokio_rustls::rustls::{Certificate, PrivateKey, ServerConfig};
+
+const ITS_CA_CERT: &str = include_str!("./itsi_ca/itsi_ca.crt");
+const ITS_CA_KEY: &str = include_str!("./itsi_ca/itsi_ca.key");
+
+// Generates a TLS configuration based on either :
+// * Input "cert" and "key" options (either paths or Base64-encoded strings) or
+// * Performs automatic certificate generation/retrieval. Generated certs use an internal self-signed Isti CA.
+// If a non-local host or optional domain parameter is provided,
+// an automated certificate will attempt to be fetched using let's encrypt.
+pub fn configure_tls(host: &str, query_params: &HashMap<String, String>) -> Result<ServerConfig> {
+    let (certs, key) = if let (Some(cert_path), Some(key_path)) =
+        (query_params.get("cert"), query_params.get("key"))
+    {
+        // Load from file or Base64
+        let certs = load_certs(cert_path);
+        let key = load_private_key(key_path);
+        (certs, key)
+    } else if query_params
+        .get("cert")
+        .map(|v| v == "auto")
+        .unwrap_or(false)
+    {
+        let domain_param = query_params.get("domain");
+        let host_string = host.to_string();
+        let domain = domain_param.or_else(|| {
+            if host_string != "localhost" {
+                Some(&host_string)
+            } else {
+                None
+            }
+        });
+
+        if let Some(domain) = domain {
+            retrieve_acme_cert(domain)?
+        } else {
+            generate_ca_signed_cert(host)?
+        }
+    } else {
+        generate_ca_signed_cert(host)?
+    };
+
+    let mut config = ServerConfig::builder()
+        .with_safe_defaults()
+        .with_no_client_auth()
+        .with_single_cert(certs, key)
+        .expect("Failed to build TLS config");
+
+    config.alpn_protocols = vec![b"h2".to_vec(), b"http/1.1".to_vec()];
+    Ok(config)
+}
+
+pub fn load_certs(path: &str) -> Vec<Certificate> {
+    let data = if let Some(stripped) = path.strip_prefix("base64:") {
+        general_purpose::STANDARD
+            .decode(stripped)
+            .expect("Invalid base64 certificate")
+    } else {
+        fs::read(path).expect("Failed to read certificate file")
+    };
+
+    if data.starts_with(b"-----BEGIN ") {
+        let mut reader = BufReader::new(&data[..]);
+        let certs_der: Vec<Vec<u8>> = certs(&mut reader)
+            .map(|r| {
+                r.map(|der| der.as_ref().to_vec())
+                    .map_err(itsi_error::ItsiError::from)
+            })
+            .collect::<Result<_>>()
+            .expect("Failed to parse certificate file");
+        certs_der.into_iter().map(Certificate).collect()
+    } else {
+        vec![Certificate(data)]
+    }
+}
+
+/// Loads a private key from a file or Base64.
+pub fn load_private_key(path: &str) -> PrivateKey {
+    let key_data = if let Some(stripped) = path.strip_prefix("base64:") {
+        general_purpose::STANDARD
+            .decode(stripped)
+            .expect("Invalid base64 private key")
+    } else {
+        fs::read(path).expect("Failed to read private key file")
+    };
+
+    if key_data.starts_with(b"-----BEGIN ") {
+        let mut reader = BufReader::new(&key_data[..]);
+        let keys: Vec<Vec<u8>> = pkcs8_private_keys(&mut reader)
+            .map(|r| {
+                r.map(|key| key.secret_pkcs8_der().to_vec())
+                    .map_err(itsi_error::ItsiError::from)
+            })
+            .collect::<Result<_>>()
+            .expect("Failed to parse private key");
+        if !keys.is_empty() {
+            return PrivateKey(keys[0].clone());
+        }
+    }
+    PrivateKey(key_data)
+}
+
+pub fn generate_ca_signed_cert(domain: &str) -> Result<(Vec<Certificate>, PrivateKey)> {
+    info!("Generating New Itsi CA - Self signed Certificate. Use `itsi ca export` to export the CA certificate for import into your local trust store.");
+
+    let ca_kp = KeyPair::from_pem(ITS_CA_KEY).unwrap();
+    let params = CertificateParams::from_ca_cert_pem(ITS_CA_CERT).unwrap();
+
+    let ca_cert = params.self_signed(&ca_kp).unwrap();
+    let ee_key = KeyPair::generate().unwrap();
+    let mut ee_params = CertificateParams::default();
+
+    // Set the domain in the subject alternative names (SAN)
+    ee_params.subject_alt_names = vec![SanType::DnsName(domain.try_into()?)];
+    // Optionally, set the Common Name (CN) in the distinguished name:
+    ee_params
+        .distinguished_name
+        .push(DnType::CommonName, domain);
+
+    ee_params.use_authority_key_identifier_extension = true;
+
+    let ee_cert = ee_params.signed_by(&ee_key, &ca_cert, &ee_key).unwrap();
+    let ee_cert_der = ee_cert.der().to_vec();
+    let ee_cert = Certificate(ee_cert_der);
+    Ok((vec![ee_cert], PrivateKey(ee_key.serialize_der())))
+}
+
+/// Retrieves an ACME certificate for a given domain.
+pub fn retrieve_acme_cert(domain: &str) -> Result<(Vec<Certificate>, PrivateKey)> {
+    warn!("Retrieving ACME cert for {}", domain);
+    generate_ca_signed_cert(domain)
+}

data/crates/itsi_server/src/server/transfer_protocol.rs

@@ -0,0 +1,23 @@
+use itsi_error::ItsiError;
+use std::str::FromStr;
+
+#[derive(Debug, Default, Clone)]
+pub enum TransferProtocol {
+    #[default]
+    Https,
+    Http,
+    Unix,
+}
+
+impl FromStr for TransferProtocol {
+    type Err = ItsiError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "http" => Ok(TransferProtocol::Http),
+            "https" => Ok(TransferProtocol::Https),
+            "unix" => Ok(TransferProtocol::Unix),
+            _ => Err(ItsiError::UnsupportedProtocol(s.to_string())),
+        }
+    }
+}

data/crates/itsi_server/src/stream_writer/mod.rs

@@ -0,0 +1,21 @@
+use bytes::Bytes;
+use magnus::{error::Result as MagnusResult, exception::io_error, Error};
+use tokio::sync::mpsc::Sender;
+
+#[magnus::wrap(class = "Itsi::StreamWriter", free_immediately, size)]
+pub struct StreamWriter {
+    sender: Sender<Bytes>,
+}
+
+impl StreamWriter {
+    pub fn new(sender: Sender<Bytes>) -> Self {
+        StreamWriter { sender }
+    }
+
+    pub fn write(&self, bytes: Bytes) -> MagnusResult<()> {
+        self.sender
+            .blocking_send(bytes)
+            .map_err(|e| Error::new(io_error(), format!("{:?}", e)))?;
+        Ok(())
+    }
+}

data/crates/itsi_tracing/Cargo.lock

@@ -0,0 +1,274 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "aho-corasick"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "itsi_tracing"
+version = "0.1.0"
+dependencies = [
+ "tracing",
+ "tracing-subscriber",
+]
+
+[[package]]
+name = "lazy_static"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
+
+[[package]]
+name = "log"
+version = "0.4.26"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "30bde2b3dc3671ae49d8e2e9f044c7c005836e7a023ee57cffa25ab82764bb9e"
+
+[[package]]
+name = "matchers"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8263075bb86c5a1b1427b5ae862e8889656f126e9f77c484496e8b47cf5c5558"
+dependencies = [
+ "regex-automata 0.1.10",
+]
+
+[[package]]
+name = "memchr"
+version = "2.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
+
+[[package]]
+name = "nu-ansi-term"
+version = "0.46.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77a8165726e8236064dbb45459242600304b42a5ea24ee2948e18e023bf7ba84"
+dependencies = [
+ "overload",
+ "winapi",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.20.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "945462a4b81e43c4e3ba96bd7b49d834c6f61198356aa858733bc4acf3cbe62e"
+
+[[package]]
+name = "overload"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39"
+
+[[package]]
+name = "pin-project-lite"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.93"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60946a68e5f9d28b0dc1c21bb8a97ee7d018a8b322fa57838ba31cc878e22d99"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.38"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0e4dccaaaf89514f546c693ddc140f729f958c247918a13380cccc6078391acc"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "regex"
+version = "1.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata 0.4.9",
+ "regex-syntax 0.8.5",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132"
+dependencies = [
+ "regex-syntax 0.6.29",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "809e8dc61f6de73b46c85f4c96486310fe304c434cfa43669d7b40f711150908"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax 0.8.5",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.6.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1"
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
+
+[[package]]
+name = "sharded-slab"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f40ca3c46823713e0d4209592e8d6e826aa57e928f09752619fc696c499637f6"
+dependencies = [
+ "lazy_static",
+]
+
+[[package]]
+name = "smallvec"
+version = "1.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7fcf8323ef1faaee30a44a340193b1ac6814fd9b7b4e88e9d4519a3e4abe1cfd"
+
+[[package]]
+name = "syn"
+version = "2.0.98"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "36147f1a48ae0ec2b5b3bc5b537d267457555a10dc06f3dbc8cb11ba3006d3b1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "thread_local"
+version = "1.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b9ef9bad013ada3808854ceac7b46812a6465ba368859a37e2100283d2d719c"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+]
+
+[[package]]
+name = "tracing"
+version = "0.1.41"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "784e0ac535deb450455cbfa28a6f0df145ea1bb7ae51b821cf5e7927fdcfbdd0"
+dependencies = [
+ "pin-project-lite",
+ "tracing-attributes",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-attributes"
+version = "0.1.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "395ae124c09f9e6918a2310af6038fba074bcf474ac352496d5910dd59a2226d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "tracing-core"
+version = "0.1.33"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e672c95779cf947c5311f83787af4fa8fffd12fb27e4993211a84bdfd9610f9c"
+dependencies = [
+ "once_cell",
+ "valuable",
+]
+
+[[package]]
+name = "tracing-log"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee855f1f400bd0e5c02d150ae5de3840039a3f54b025156404e34c23c03f47c3"
+dependencies = [
+ "log",
+ "once_cell",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-subscriber"
+version = "0.3.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e8189decb5ac0fa7bc8b96b7cb9b2701d60d48805aca84a238004d665fcc4008"
+dependencies = [
+ "matchers",
+ "nu-ansi-term",
+ "once_cell",
+ "regex",
+ "sharded-slab",
+ "smallvec",
+ "thread_local",
+ "tracing",
+ "tracing-core",
+ "tracing-log",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "00e2473a93778eb0bad35909dff6a10d28e63f792f16ed15e404fca9d5eeedbe"
+
+[[package]]
+name = "valuable"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65"
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"

data/crates/itsi_tracing/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "itsi_tracing"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+tracing = { version = "0.1.41", features = ["attributes"] }
+tracing-subscriber = { version = "0.3.19", features = [
+  "env-filter",
+  "std",
+  "fmt",
+] }