Struct LoggingMeshClient 

pub struct LoggingMeshClient { /* private fields */ }

LoggingMeshClient is the Python-facing handle for distributed logging over a ProcMesh.

Calling spawn(...) builds three pieces of logging infra:

• client_actor: a single LogClientActor running in the local process. It aggregates forwarded stdout/stderr, batches it, and coordinates sync flush barriers.

• forwarder_mesh: (optional) an ActorMesh<LogForwardActor> with one actor per remote proc. Each LogForwardActor sits in that proc and forwards its stdout/stderr back to the client. This mesh only exists if MESH_ENABLE_LOG_FORWARDING was true at startup; otherwise it’s None and we never spawn any forwarders.

• logger_mesh: an ActorMesh<LoggerRuntimeActor> with one actor per remote proc. Each LoggerRuntimeActor controls that proc’s Python logging runtime (log level, handlers, etc.). This mesh is always created, even if forwarding is disabled.

The Python object you get back holds references to all of this so that you can:

• toggle streaming vs “stay quiet” (set_mode(...)),
• adjust the per-proc Python log level (set_mode(...)),
• force a sync flush of forwarded output and wait for completion (flush(...)).

Drop semantics: Dropping the Python handle runs Drop on this Rust struct, which drains/stops the local LogClientActor but does not synchronously tear down the per-proc meshes. The remote LogForwardActor / LoggerRuntimeActor instances keep running until the remote procs themselves are shut down (e.g. via host_mesh.shutdown(...) in tests).

Trait Implementations

impl Drop for LoggingMeshClient

fn drop(&mut self)

Executes the destructor for this type.

impl<'py> IntoPyObject<'py> for LoggingMeshClient

type Target = LoggingMeshClient

The Python output type

type Output = Bound<'py, <LoggingMeshClient as IntoPyObject<'py>>::Target>

The smart pointer type to use.

type Error = PyErr

The type returned in the event of a conversion error.

fn into_pyobject( self, py: Python<'py>, ) -> Result<<Self as IntoPyObject<'_>>::Output, <Self as IntoPyObject<'_>>::Error>

Performs the conversion.

impl PyClass for LoggingMeshClient

type Frozen = True

Whether the pyclass is frozen.

impl PyClassImpl for LoggingMeshClient

const IS_BASETYPE: bool = false

#[pyclass(subclass)]

const IS_SUBCLASS: bool = false

#[pyclass(extends=…)]

const IS_MAPPING: bool = false

#[pyclass(mapping)]

const IS_SEQUENCE: bool = false

#[pyclass(sequence)]

const IS_IMMUTABLE_TYPE: bool = false

#[pyclass(immutable_type)]

const RAW_DOC: &'static CStr = /// `LoggingMeshClient` is the Python-facing handle for distributed /// logging over a `ProcMesh`. /// /// Calling `spawn(...)` builds three pieces of logging infra: /// /// - `client_actor`: a single `LogClientActor` running in the /// *local* process. It aggregates forwarded stdout/stderr, /// batches it, and coordinates sync flush barriers. /// /// - `forwarder_mesh`: (optional) an `ActorMesh<LogForwardActor>` /// with one actor per remote proc. Each `LogForwardActor` sits in /// that proc and forwards its stdout/stderr back to the client. /// This mesh only exists if `MESH_ENABLE_LOG_FORWARDING` was `true` /// at startup; otherwise it's `None` and we never spawn any /// forwarders. /// /// - `logger_mesh`: an `ActorMesh<LoggerRuntimeActor>` with one /// actor per remote proc. Each `LoggerRuntimeActor` controls that /// proc's Python logging runtime (log level, handlers, etc.). /// This mesh is always created, even if forwarding is disabled. /// /// The Python object you get back holds references to all of this so /// that you can: /// - toggle streaming vs "stay quiet" (`set_mode(...)`), /// - adjust the per-proc Python log level (`set_mode(...)`), /// - force a sync flush of forwarded output and wait for completion /// (`flush(...)`). /// /// Drop semantics: /// Dropping the Python handle runs `Drop` on this Rust struct, /// which drains/stops the local `LogClientActor` but does *not* /// synchronously tear down the per-proc meshes. The remote /// `LogForwardActor` / `LoggerRuntimeActor` instances keep running /// until the remote procs themselves are shut down (e.g. via /// `host_mesh.shutdown(...)` in tests).

Docstring for the class provided on the struct or enum.

const DOC: &'static CStr

Fully rendered class doc, including the text_signature if a constructor is defined.

type BaseType = PyAny

Base class

type ThreadChecker = SendablePyClass<LoggingMeshClient>

This handles following two situations:

type Inventory = Pyo3MethodsInventoryForLoggingMeshClient

type PyClassMutability = <<PyAny as PyClassBaseType>::PyClassMutability as PyClassMutability>::ImmutableChild

Immutable or mutable

type Dict = PyClassDummySlot

Specify this class has #[pyclass(dict)] or not.

type WeakRef = PyClassDummySlot

Specify this class has #[pyclass(weakref)] or not.

type BaseNativeType = PyAny

The closest native ancestor. This is PyAny by default, and when you declare #[pyclass(extends=PyDict)], it’s PyDict.

fn items_iter() -> PyClassItemsIter

fn lazy_type_object() -> &'static LazyTypeObject<Self>

fn dict_offset() -> Option<isize>

fn weaklist_offset() -> Option<isize>

impl<'a, 'holder, 'py> PyFunctionArgument<'a, 'holder, 'py, false> for &'holder LoggingMeshClient

type Holder = Option<PyClassGuard<'a, LoggingMeshClient>>

fn extract( obj: &'a Bound<'py, PyAny>, holder: &'holder mut Self::Holder, ) -> PyResult<Self>

impl PyTypeInfo for LoggingMeshClient

const NAME: &'static str = "LoggingMeshClient"

Class name.

const MODULE: Option<&'static str>

Module name, if any.

fn type_object_raw(py: Python<'_>) -> *mut PyTypeObject

Returns the PyTypeObject instance for this type.

fn type_object(py: Python<'_>) -> Bound<'_, PyType>

Returns the safe abstraction over the type object.

fn is_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type or a subclass of this type.

fn is_exact_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type.

impl DerefToPyAny for LoggingMeshClient