> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.nvidia.com/holoscan/sdk-user-guide/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.nvidia.com/holoscan/sdk-user-guide/_mcp/server.

# holoscan::AsyncDataLoggerResource

> Asynchronous data logger.

Asynchronous data logger.

Maintains a queue of items to be logged that are processed by a background thread.

The [`log_data`](#logdata) method is used to send data entries to the primary data queue and is intended to be used to log most data types (e.g. strings, numeric types, small structs, etc.).

This logger can be operated in single queue or dual queue modes.

When the `enable_large_data_queue` parameter is true, a separate queue will be available for "large" data (e.g. [Tensor](tensor) and [TensorMap](tensormap) data). This large data queue is processed by a separate worker thread. If `log_tensor_data_contents` is true, it is expected that `AsyncDataLoggerBackend::process_large_entry` would handle logging the actual tensor contents. The `AsyncDataLoggerBackend::process_entry` method corresponding to the primary queue would typically be designed to log only generic tensor attributes such as shape and dtype.

The dual queue design allows for prioritized processing and selective dropping of large data contents while preserving important metadata if the large data queue becomes full. It is the responsibility of the backend ([`AsyncDataLoggerBackend`](asyncdataloggerbackend)) to determine which data types to log to which queue.

When `enable_large_data_queue` is false, "large" data is sent to the primary queue instead.

Both queues should handle logging the [`MetadataDictionary`](metadatadictionary) when Holoscan's metadata feature is enabled.

The `shutdown_wait_period_ms` parameter controls how long the logger waits for remaining messages in the queue(s) to be processed during shutdown. A negative value (default) means wait indefinitely, 0 means don't wait at all, and a positive value specifies the timeout in milliseconds. The `HOLOSCAN_ASYNC_LOGGER_SHUTDOWN_WAIT_MS` environment variable can be used to override this value. During shutdown, this resource emits INFO logs that include the component name, approximate queue depths, entries processed so far, and a final summary when worker threads have finished; WARN is used if a drain timeout expires and entries are discarded.

Inherited parameters from [DataLoggerResource](dataloggerresource):

* **log\_inputs**: bool (optional, default: true)
* **log\_outputs**: bool (optional, default: true)
* **log\_metadata**: bool (optional, default: true)
* **log\_tensor\_data\_content**: bool (optional, default: false)
* **use\_scheduler\_clock**: bool (optional, default: false)
* **allowlist\_patterns**: std::vector\<std::string> (optional, default: empty)
* **denylist\_patterns**: std::vector\<std::string> (optional, default: empty)

See the [DataLoggerResource](dataloggerresource) documentation for details on these inherited parameters.

```cpp showLineNumbers={false}
#include <holoscan/async_data_logger.hpp>
```

**Inherits from:** `holoscan::DataLoggerResource` (public)

***

## Constructors

### AsyncDataLoggerResource \[#asyncdataloggerresource]

```cpp showLineNumbers={false}
holoscan::AsyncDataLoggerResource::AsyncDataLoggerResource() = default
```

The following overloads are deleted to prevent misuse:

```cpp showLineNumbers={false}
holoscan::AsyncDataLoggerResource::AsyncDataLoggerResource(const AsyncDataLoggerResource &) = delete;
holoscan::AsyncDataLoggerResource::AsyncDataLoggerResource(AsyncDataLoggerResource &&) = delete;
```

### Destructor \[#destructor]

### \~AsyncDataLoggerResource

```cpp showLineNumbers={false}
holoscan::AsyncDataLoggerResource::~AsyncDataLoggerResource() override
```

***

## Assignment operators

### operator= \[#operator\_assign]

The following overloads are deleted to prevent misuse:

```cpp showLineNumbers={false}
AsyncDataLoggerResource & holoscan::AsyncDataLoggerResource::operator=(const AsyncDataLoggerResource &) = delete;
AsyncDataLoggerResource & holoscan::AsyncDataLoggerResource::operator=(AsyncDataLoggerResource &&) = delete;
```

***

## Methods

### setup \[#setup]

```cpp showLineNumbers={false}
void holoscan::AsyncDataLoggerResource::setup(
    ComponentSpec &spec
) override
```

Define the resource specification.

**Parameters**

The reference to the component specification.

### initialize \[#initialize]

```cpp showLineNumbers={false}
void holoscan::AsyncDataLoggerResource::initialize() override
```

Initialize the component.

This method is called only once when the component is created for the first time, and use of light-weight initialization.

### log\_data \[#logdata]

```cpp showLineNumbers={false}
bool holoscan::AsyncDataLoggerResource::log_data(
    const std::any &data,
    const std::string &unique_id,
    int64_t acquisition_timestamp = -1,
    const std::shared_ptr<MetadataDictionary> &metadata = nullptr,
    IOSpec::IOType io_type = IOSpec::IOType::kOutput,
    std::optional<cudaStream_t> stream = std::nullopt
) override
```

Logs a message.

The unique\_id for the message will have the form:

* operator\_name.port\_name
* operator\_name.port\_name:index (for multi-receivers with N:1 connection)

For distributed applications, the fragment name will also appear in the unique id:

* fragment\_name.operator\_name.port\_name
* fragment\_name.operator\_name.port\_name:index

**Returns:** true if logging (including serialization and sending) was successful, false otherwise.

**Parameters**

The data to log, passed as std::any.

A unique identifier for the message.

Timestamp when the data was acquired (-1 if unknown).

Associated metadata dictionary for the message.

The type of I/O port (kInput or kOutput).

Optional CUDA stream for GPU operations.

### log\_tensor\_data \[#logtensordata]

```cpp showLineNumbers={false}
bool holoscan::AsyncDataLoggerResource::log_tensor_data(
    const std::shared_ptr<Tensor> &tensor,
    const std::string &unique_id,
    int64_t acquisition_timestamp = -1,
    const std::shared_ptr<MetadataDictionary> &metadata = nullptr,
    IOSpec::IOType io_type = IOSpec::IOType::kOutput,
    std::optional<cudaStream_t> stream = std::nullopt
) override
```

Logs a [Tensor](tensor) with optional data content logging.

This specialized method allows efficient logging of tensor metadata without the overhead of logging large tensor data arrays when only header information is needed.

The unique\_id for the message will have the form:

* operator\_name.port\_name
* operator\_name.port\_name:index (for multi-receivers with N:1 connection)

For distributed applications, the fragment name will also appear in the unique id:

* fragment\_name.operator\_name.port\_name
* fragment\_name.operator\_name.port\_name:index

**Returns:** true if logging was successful, false otherwise.

**Parameters**

The [Tensor](tensor) to log.

A unique identifier for the message.

Timestamp when the data was acquired (-1 if unknown).

Associated metadata dictionary for the message.

The type of I/O port (kInput or kOutput).

Optional CUDA stream for GPU operations.

### log\_tensormap\_data \[#logtensormapdata]

```cpp showLineNumbers={false}
bool holoscan::AsyncDataLoggerResource::log_tensormap_data(
    const TensorMap &tensor_map,
    const std::string &unique_id,
    int64_t acquisition_timestamp = -1,
    const std::shared_ptr<MetadataDictionary> &metadata = nullptr,
    IOSpec::IOType io_type = IOSpec::IOType::kOutput,
    std::optional<cudaStream_t> stream = std::nullopt
) override
```

Logs a [TensorMap](tensormap) with optional data content logging.

This specialized method allows efficient logging of tensor map metadata without the overhead of logging large tensor data arrays when only header information is needed.

The unique\_id for the message will have the form:

* operator\_name.port\_name
* operator\_name.port\_name:index (for multi-receivers with N:1 connection)

For distributed applications, the fragment name will also appear in the unique id:

* fragment\_name.operator\_name.port\_name
* fragment\_name.operator\_name.port\_name:index

**Returns:** true if logging was successful, false otherwise.

**Parameters**

The [TensorMap](tensormap) to log.

A unique identifier for the message.

Timestamp when the data was acquired (-1 if unknown).

Associated metadata dictionary for the message.

The type of I/O port (kInput or kOutput).

Optional CUDA stream for GPU operations.

### log\_backend\_specific \[#logbackendspecific]

```cpp showLineNumbers={false}
bool holoscan::AsyncDataLoggerResource::log_backend_specific(
    const std::any &data,
    const std::string &unique_id,
    int64_t acquisition_timestamp = -1,
    const std::shared_ptr<MetadataDictionary> &metadata = nullptr,
    IOSpec::IOType io_type = IOSpec::IOType::kOutput,
    std::optional<cudaStream_t> stream = std::nullopt
) override
```

Logs backend-specific data types.

This method is called for logging backend-specific data types (intended for use with backends that have separate emit/receive codepaths for backend-specific types). The data parameter is kept as std::any here to avoid making the base interface specific to a particular backend, but a backend-specific concrete implementation should be provided as needed via run-time type checking.

A concrete example of a backend-specific type is the GXF Entity type which is a heterogeneous collection of components. An implementation of this method for GXF entities is provided in the concrete implementation of the GXFConsoleLogger.

The unique\_id for the message will have the form:

* operator\_name.port\_name
* operator\_name.port\_name:index (for multi-receivers with N:1 connection)

For distributed applications, the fragment name will also appear in the unique id:

* fragment\_name.operator\_name.port\_name
* fragment\_name.operator\_name.port\_name:index

**Returns:** true if logging was successful, false if backend-specific logging is not supported.

**Parameters**

The backend-specific data to log, passed as std::any.

A unique identifier for the message.

Timestamp when the data was acquired (-1 if unknown).

Associated metadata dictionary for the message.

The type of I/O port (kInput or kOutput).

Optional CUDA stream for GPU operations.

### shutdown \[#shutdown]

```cpp showLineNumbers={false}
void holoscan::AsyncDataLoggerResource::shutdown() override
```

Shutdown the data logger.

This method should be called to properly shutdown the data logger, including stopping any background threads and releasing resources. The default implementation does nothing. Data loggers that use background threads or other resources should override this method to perform proper cleanup.

### set\_backend \[#setbackend]

```cpp showLineNumbers={false}
void holoscan::AsyncDataLoggerResource::set_backend(
    std::shared_ptr<AsyncDataLoggerBackend> backend
)
```

### get\_statistics \[#getstatistics]

```cpp showLineNumbers={false}
std::string holoscan::AsyncDataLoggerResource::get_statistics() const
```

### get\_data\_dropped\_count \[#getdatadroppedcount]

```cpp showLineNumbers={false}
size_t holoscan::AsyncDataLoggerResource::get_data_dropped_count() const
```

### get\_large\_data\_dropped\_count \[#getlargedatadroppedcount]

```cpp showLineNumbers={false}
size_t holoscan::AsyncDataLoggerResource::get_large_data_dropped_count() const
```

### get\_data\_queue\_size \[#getdataqueuesize]

```cpp showLineNumbers={false}
size_t holoscan::AsyncDataLoggerResource::get_data_queue_size() const
```

### get\_large\_data\_queue\_size \[#getlargedataqueuesize]

```cpp showLineNumbers={false}
size_t holoscan::AsyncDataLoggerResource::get_large_data_queue_size() const
```

### should\_log\_message \[#shouldlogmessage]

```cpp showLineNumbers={false}
bool holoscan::AsyncDataLoggerResource::should_log_message(
    const std::string &unique_id
) const
```

Checks if a message with the given unique\_id should be logged based on allowlist/denylist patterns.

This utility function implements the filtering logic:

* First check if `denylist patterns` are specified and if there is a match, do not log it.
* Next check if `allowlist_patterns` were specified:
  If no, return true (allow everything)
  If yes, return true only if there is a match to the specified patterns.
  * If no, return true (allow everything)
  * If yes, return true only if there is a match to the specified patterns.

**Returns:** true if the message should be logged, false otherwise.

**Parameters**

The unique identifier to check against patterns.

### should\_log\_output \[#shouldlogoutput]

```cpp showLineNumbers={false}
bool holoscan::AsyncDataLoggerResource::should_log_output() const override
```

Checks if the logger should log output ports.

If False, the data logger will not be applied during op\_input.emit() calls from [Operator::compute](gpuresidentoperator#compute).

**Returns:** true if the logger should log output ports, false otherwise.

### should\_log\_input \[#shouldloginput]

```cpp showLineNumbers={false}
bool holoscan::AsyncDataLoggerResource::should_log_input() const override
```

Checks if the logger should log input ports.

If False, the data logger will not be applied during op\_input.receive() calls from [Operator::compute](gpuresidentoperator#compute).

**Returns:** true if the logger should log input ports, false otherwise.

### should\_log\_metadata \[#shouldlogmetadata]

```cpp showLineNumbers={false}
bool holoscan::AsyncDataLoggerResource::should_log_metadata() const
```

Checks if the logger should log metadata.

If False, the data logger will not log metadata for each operator.

**Returns:** true if the logger should log metadata, false otherwise.

### should\_log\_tensor\_data\_content \[#shouldlogtensordatacontent]

```cpp showLineNumbers={false}
bool holoscan::AsyncDataLoggerResource::should_log_tensor_data_content() const
```

Checks if the logger should log tensor data content.

If False, only tensor header information will be logged, not the actual data arrays. When true, the full tensor data is also logged.

**Returns:** true if the logger should log tensor data content, false otherwise.

### get\_timestamp \[#gettimestamp]

```cpp showLineNumbers={false}
virtual int64_t holoscan::AsyncDataLoggerResource::get_timestamp() const
```

Get the current timestamp for logging operations.

This method is called internally by the logging functions to obtain timestamps for emit\_timestamp (when io\_type==IOSpec::IOType::kOutput) or receive\_timestamp (when io\_type==IOSpec::IOType::kInput). The default implementation provides high-resolution timestamps in microseconds since epoch. Implementations can override this to provide custom timing mechanisms as appropriate.

**Returns:** Current timestamp in microseconds since epoch, or -1 if not available.

### resource\_type \[#resourcetype]

```cpp showLineNumbers={false}
ResourceType holoscan::Resource::resource_type() const
```

Get the resource type.

**Returns:** The resource type.

### name \[#name]

```cpp showLineNumbers={false}
Resource & holoscan::Resource::name(
    const std::string &name
) &
```

Set the name of the resource.

**Returns:** The reference to the resource.

**Parameters**

The name of the resource.

```cpp showLineNumbers={false}
Resource && holoscan::Resource::name(
    const std::string &name
) &&
```

Set the name of the resource.

**Returns:** The reference to the resource.

**Parameters**

The name of the resource.

const

```cpp showLineNumbers={false}
const std::string & holoscan::ComponentBase::name() const
```

Get the name of the component.

**Returns:** The name of the component.

### fragment \[#fragment]

```cpp showLineNumbers={false}
Resource & holoscan::Resource::fragment(
    Fragment *fragment
)
```

Set the fragment of the resource.

**Returns:** The reference to the resource.

**Parameters**

The pointer to the fragment of the resource.

```cpp showLineNumbers={false}
Fragment * holoscan::ComponentBase::fragment()
```

Get a pointer to [Fragment](fragment) object.

**Returns:** The Pointer to [Fragment](fragment) object.

const

```cpp showLineNumbers={false}
const Fragment * holoscan::ComponentBase::fragment() const
```

Get a const pointer to [Fragment](fragment) object.

**Returns:** The const pointer to [Fragment](fragment) object.

### spec \[#spec]

```cpp showLineNumbers={false}
Resource & holoscan::Resource::spec(
    const std::shared_ptr<ComponentSpec> &spec
)
```

Set the component specification to the resource.

**Returns:** The reference to the resource.

**Parameters**

The component specification.

```cpp showLineNumbers={false}
ComponentSpec * holoscan::Resource::spec()
```

Get the component specification of the resource.

**Returns:** The pointer to the component specification.

### spec\_shared \[#specshared]

```cpp showLineNumbers={false}
std::shared_ptr<ComponentSpec> holoscan::Resource::spec_shared()
```

Get the shared pointer to the component spec.

**Returns:** The shared pointer to the component spec.

### to\_yaml\_node \[#toyamlnode]

```cpp showLineNumbers={false}
YAML::Node holoscan::Resource::to_yaml_node() const override
```

Get a `YAML` representation of the resource.

**Returns:** `YAML` node including spec of the resource in addition to the base component properties.

### set\_parameters \[#setparameters]

```cpp showLineNumbers={false}
void holoscan::Resource::set_parameters() override
```

Set the parameters based on defaults (sets GXF parameters for GXF components).

### id \[#id]

```cpp showLineNumbers={false}
int64_t holoscan::ComponentBase::id() const
```

Get the identifier of the component.

By default, the identifier is set to -1. It is set to a valid value when the component is initialized.

With the default executor (GXFExecutor), the identifier is set to the GXF component ID.

**Returns:** The identifier of the component.

### add\_arg \[#addarg]

```cpp showLineNumbers={false}
void holoscan::ComponentBase::add_arg(
    const Arg &arg
)
```

Add an argument to the component.

**Parameters**

The argument to add.

```cpp showLineNumbers={false}
void holoscan::ComponentBase::add_arg(
    Arg &&arg
)
```

Add an argument to the component.

**Parameters**

The argument to add.

```cpp showLineNumbers={false}
void holoscan::ComponentBase::add_arg(
    const ArgList &arg
)
```

Add a list of arguments to the component.

**Parameters**

The list of arguments to add.

```cpp showLineNumbers={false}
void holoscan::ComponentBase::add_arg(
    ArgList &&arg
)
```

Add a list of arguments to the component.

**Parameters**

The list of arguments to add.

### args \[#args]

```cpp showLineNumbers={false}
std::vector<Arg> & holoscan::ComponentBase::args()
```

Get the list of arguments.

**Returns:** The vector of arguments.

### description \[#description]

```cpp showLineNumbers={false}
std::string holoscan::ComponentBase::description() const
```

Get a description of the component.

**Returns:** `YAML` string.

**See also:**
to\_yaml\_node()

### service \[#service]

```cpp showLineNumbers={false}
template <typename ServiceT = DefaultFragmentService>
std::shared_ptr<ServiceT> holoscan::ComponentBase::service(
    std::string_view id = ""
) const
```

Retrieve a registered fragment service or resource.

Retrieves a previously registered fragment service or resource by its type and optional identifier. Returns nullptr if no service/resource is found with the specified type and identifier.

Note that any changes to the service retrieval logic in this method should be synchronized with the implementation in `Fragment::service()` method to maintain consistency.

**Returns:** The shared pointer to the service/resource, or nullptr if not found or if type casting fails.

**Template parameters**

The type of the service/resource to retrieve. Must inherit from either [Resource](resource) or [FragmentService](fragmentservice). Defaults to [DefaultFragmentService](defaultfragmentservice) if not specified.

**Parameters**

The identifier of the service/resource. If empty, retrieves by type only.

### get\_service\_by\_type\_info \[#getservicebytypeinfo]

```cpp showLineNumbers={false}
std::shared_ptr<FragmentService> holoscan::ComponentBase::get_service_by_type_info(
    const std::type_info &service_type,
    std::string_view id = ""
) const
```

Retrieve a registered fragment service or resource for Python bindings.

This is a helper method for Python bindings to retrieve a service by its C++ type info.

**Returns:** The shared pointer to the base service, or nullptr if not found.

**Parameters**

The type info of the service/resource to retrieve.

The identifier of the service/resource. If empty, retrieves by type only.

### reset\_backend\_objects \[#resetbackendobjects]

```cpp showLineNumbers={false}
virtual void holoscan::ComponentBase::reset_backend_objects()
```

Reset any backend-specific objects (e.g. GXF GraphEntity).

### start\_worker\_threads \[#startworkerthreads]

```cpp showLineNumbers={false}
bool holoscan::AsyncDataLoggerResource::start_worker_threads()
```

### stop\_worker\_threads \[#stopworkerthreads]

```cpp showLineNumbers={false}
void holoscan::AsyncDataLoggerResource::stop_worker_threads()
```

### data\_worker\_function \[#dataworkerfunction]

```cpp showLineNumbers={false}
void holoscan::AsyncDataLoggerResource::data_worker_function()
```

### large\_data\_worker\_function \[#largedataworkerfunction]

```cpp showLineNumbers={false}
void holoscan::AsyncDataLoggerResource::large_data_worker_function()
```

### enqueue\_data\_entry \[#enqueuedataentry]

```cpp showLineNumbers={false}
bool holoscan::AsyncDataLoggerResource::enqueue_data_entry(
    DataEntry &&entry
)
```

### enqueue\_large\_data\_entry \[#enqueuelargedataentry]

```cpp showLineNumbers={false}
bool holoscan::AsyncDataLoggerResource::enqueue_large_data_entry(
    DataEntry &&entry
)
```

### copy\_value\_from\_args \[#copyvaluefromargs]

```cpp showLineNumbers={false}
template <typename ArgT>
ArgT holoscan::AsyncDataLoggerResource::copy_value_from_args(
    const std::string &arg_name,
    ArgT default_value
)
```

Helper function to extract typed values from component arguments.

This function handles both direct values and `YAML` node values, providing robust parameter extraction with fallback to default values.

For a concrete example, see how this function is used in `AsyncConsoleLogger`.

**Returns:** The extracted value or the default value

**Template parameters**

The type of the argument to extract

**Parameters**

The name of the argument to look for

The default value to return if the argument is not found or cannot be parsed

### update\_params\_from\_args \[#updateparamsfromargs]

```cpp showLineNumbers={false}
void holoscan::Resource::update_params_from_args()
```

Update parameters based on the specified arguments.

```cpp showLineNumbers={false}
void holoscan::ComponentBase::update_params_from_args(
    std::unordered_map<std::string, ParameterWrapper> &params
)
```

Update parameters based on the specified arguments.

### service\_provider \[#serviceprovider]

```cpp showLineNumbers={false}
void holoscan::ComponentBase::service_provider(
    FragmentServiceProvider *provider
)
```

Set the service provider that owns this component.

***

## Static methods

### register\_converter \[#registerconverter]

```cpp showLineNumbers={false}
template <typename typeT>
static void holoscan::ComponentBase::register_converter()
```

Register the argument setter for the given type.

If an operator or resource has an argument with a custom type, the argument setter must be registered using this method.

The argument setter is used to set the value of the argument from the `YAML` configuration.

This method can be called in the initialization phase of the operator/resource (e.g., `initialize()`). The example below shows how to register the argument setter for the custom type (`Vec3`):

It is assumed that `YAML::convert<T>::encode` and `YAML::convert<T>::decode` are implemented for the given type. You need to specialize the `YAML::convert<>` template class.

For example, suppose that you had a `Vec3` class with the following members:

You can define the `YAML::convert<Vec3>` as follows in a '.cpp' file:

Please refer to the [yaml-cpp documentation](https://github.com/jbeder/yaml-cpp/wiki/Tutorial#converting-tofrom-native-data-types) for more details.

**Template parameters**

The type of the argument to register.

**Example**

```cpp showLineNumbers={false}
void MyOp::initialize() {
  register_converter<Vec3>();
}
```

**Example**

```cpp showLineNumbers={false}
struct Vec3 {
  // make sure you have overloaded operator==() for the comparison
  double x, y, z;
};
```

**Example**

```cpp showLineNumbers={false}
namespace YAML {
template<>
struct convert<Vec3> {
  static Node encode(const Vec3& rhs) {
    Node node;
    node.push_back(rhs.x);
    node.push_back(rhs.y);
    node.push_back(rhs.z);
    return node;
  }

  static bool decode(const Node& node, Vec3& rhs) {
    if(!node.IsSequence() || node.size() != 3) {
      return false;
    }

    rhs.x = node[0].as<double>();
    rhs.y = node[1].as<double>();
    rhs.z = node[2].as<double>();
    return true;
  }
};
}
```

### register\_argument\_setter \[#registerargumentsetter]

```cpp showLineNumbers={false}
template <typename typeT>
void holoscan::ComponentBase::register_argument_setter()
```

Register the argument setter for the given type.

Please refer to the documentation of `register_converter()` for more details.

**Template parameters**

The type of the argument to register.

***

## Types

### ResourceType

[Resource](resource) type used for the initialization of the resource.

| Name      | Value | Description      |
| --------- | ----- | ---------------- |
| `kNative` |       | Native resource. |
| `kGXF`    |       | GXF resource.    |

***

## Member variables

| Name                              | Type                                              | Description                                       |
| --------------------------------- | ------------------------------------------------- | ------------------------------------------------- |
| `max_queue_size_`                 | `Parameter< size_t >`                             |                                                   |
| `worker_sleep_time_`              | `Parameter< int64_t >`                            |                                                   |
| `queue_policy_`                   | `Parameter< AsyncQueuePolicy >`                   |                                                   |
| `large_data_max_queue_size_`      | `Parameter< size_t >`                             |                                                   |
| `large_data_worker_sleep_time_`   | `Parameter< int64_t >`                            |                                                   |
| `large_data_queue_policy_`        | `Parameter< AsyncQueuePolicy >`                   |                                                   |
| `enable_large_data_queue_`        | `Parameter< bool >`                               |                                                   |
| `shutdown_wait_period_ms_`        | `Parameter< int64_t >`                            |                                                   |
| `queue_type_`                     | `Parameter< DataLoggerQueueType >`                |                                                   |
| `log_outputs_`                    | `Parameter< bool >`                               |                                                   |
| `log_inputs_`                     | `Parameter< bool >`                               |                                                   |
| `log_metadata_`                   | `Parameter< bool >`                               |                                                   |
| `log_tensor_data_content_`        | `Parameter< bool >`                               |                                                   |
| `use_scheduler_clock_`            | `Parameter< bool >`                               |                                                   |
| `clock_`                          | `Parameter< std::shared_ptr< Resource > >`        |                                                   |
| `clock_interface_`                | `std::shared_ptr< ClockInterface >`               | Cached clock interface used by get\_timestamp().  |
| `allowlist_patterns_`             | `Parameter< std::vector< std::string > >`         |                                                   |
| `denylist_patterns_`              | `Parameter< std::vector< std::string > >`         |                                                   |
| `resource_type_`                  | `ResourceType`                                    | The type of the resource.                         |
| `is_initialized_`                 | `bool`                                            | Whether the resource is initialized.              |
| `spec_`                           | `std::shared_ptr< ComponentSpec >`                | The component specification.                      |
| `id_`                             | `int64_t`                                         | The ID of the component.                          |
| `name_`                           | `std::string`                                     | Name of the component.                            |
| `fragment_`                       | `Fragment *`                                      | Pointer to the fragment that owns this component. |
| `args_`                           | `std::vector< Arg >`                              | List of arguments.                                |
| `service_provider_`               | `FragmentServiceProvider *`                       | Pointer to the service provider.                  |
| `data_queue_`                     | `std::unique_ptr< DataLoggerQueue< DataEntry > >` |                                                   |
| `large_data_queue_`               | `std::unique_ptr< DataLoggerQueue< DataEntry > >` |                                                   |
| `data_worker_`                    | `std::thread`                                     |                                                   |
| `large_data_worker_`              | `std::thread`                                     |                                                   |
| `shutdown_requested_`             | `std::atomic< bool >`                             |                                                   |
| `workers_running_`                | `std::atomic< bool >`                             |                                                   |
| `backend_shutdown_called_`        | `std::atomic< bool >`                             |                                                   |
| `shutdown_drain_timeout_expired_` | `std::atomic< bool >`                             |                                                   |
| `data_dropped_`                   | `std::atomic< size_t >`                           |                                                   |
| `data_processed_`                 | `std::atomic< size_t >`                           |                                                   |
| `data_enqueued_`                  | `std::atomic< size_t >`                           |                                                   |
| `large_data_dropped_`             | `std::atomic< size_t >`                           |                                                   |
| `large_data_processed_`           | `std::atomic< size_t >`                           |                                                   |
| `large_data_enqueued_`            | `std::atomic< size_t >`                           |                                                   |
| `backend_`                        | `std::shared_ptr< AsyncDataLoggerBackend >`       |                                                   |
| `backend_initialized_`            | `std::atomic< bool >`                             |                                                   |