> 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::DataLoggerResource

> Base class for all data logger resources.

Base class for all data logger resources.

This class provides the core functionality for logging data to the console. Concrete implementations of this class should provide the actual logging functionality.

\==Parameters ==

* **log\_inputs**: bool (optional, default: true)
  Globally enable or disable logging on input ports (InputContext::receive calls)
  * Globally enable or disable logging on input ports ([`InputContext::receive`](inputcontext#receive) calls)
* **log\_outputs**: bool (optional, default: true)
  Globally enable or disable logging on output ports (OutputContext::emit calls)
  * Globally enable or disable logging on output ports ([`OutputContext::emit`](outputcontext#emit) calls)
* **log\_metadata**: bool (optional, default: true)
  Globally enable or disable logging of MetadataDictionary contents
  * Globally enable or disable logging of [MetadataDictionary](metadatadictionary) contents
* **log\_tensor\_data\_contents**: bool (optional, default: true)
  Enable logging of the contents of tensors, not just basic description information. Note that logging GPU tensor contents will have the overhead of a device to host data transfer.
  * Enable logging of the contents of tensors, not just basic description information. Note that logging GPU tensor contents will have the overhead of a device to host data transfer.
* **use\_scheduler\_clock**: bool (optional, default: false)
  Whether the get\_timestamp() method uses the scheduler's clock for timestamps (if false, uses system clock).
  * Whether the `get_timestamp()` method uses the scheduler's clock for timestamps (if false, uses system clock).
* **allowlist\_patterns**: std::vector\<std::string> (optional, default: empty vector)
* **denylist\_patterns**: std::vector\<std::string> (optional, default: empty vector)

Note on allowlist/denylist pattern matching:

If `allowlist_patterns` or `denylist_patterns` are specified, they are applied to the `unique_id` assigned to messages by the underlying framework.

In a non-distributed application (without a fragment name), the unique\_id for a message will have one of the following forms:

* 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 (for multi-receivers with N:1 connection)

The pattern matching logic is as follows:

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

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

**Inherits from:** `holoscan::DataLogger` (public), `holoscan::Resource` (public)

***

## Constructors

### DataLoggerResource \[#dataloggerresource]

#### Move

inline

explicit

```cpp showLineNumbers={false}
template <typename ArgT,
          typename... ArgsT,
          typename = std::enable_if_t<!std::is_base_of_v<::holoscan::Resource, std::decay_t<ArgT>> &&   (std::is_same_v<::holoscan::Arg, std::decay_t<ArgT>> ||   std::is_same_v<::holoscan::ArgList, std::decay_t<ArgT>>)>>
holoscan::DataLoggerResource::DataLoggerResource(
    ArgT &&arg,
    ArgsT &&... args
)
```

#### Default

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

### Destructor \[#destructor]

### \~DataLoggerResource

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

***

## Methods

### setup \[#setup]

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

Defines parameters for the logging resource, including the serializer.

**Parameters**

The component specification.

### log\_data \[#logdata]

```cpp showLineNumbers={false}
bool holoscan::DataLoggerResource::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::DataLoggerResource::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::DataLoggerResource::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::DataLoggerResource::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.

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

```cpp showLineNumbers={false}
bool holoscan::DataLoggerResource::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::DataLoggerResource::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::DataLoggerResource::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::DataLoggerResource::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::DataLoggerResource::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::DataLoggerResource::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.

### initialize \[#initialize]

```cpp showLineNumbers={false}
void holoscan::DataLoggerResource::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.

### shutdown \[#shutdown]

```cpp showLineNumbers={false}
virtual void holoscan::DataLoggerResource::shutdown()
```

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.

### resource\_type \[#resourcetype]

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

Get the resource type.

**Returns:** The resource type.

### name \[#name]

#### Set the name of the resource (1)

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

Set the name of the resource.

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

**Parameters**

The name of the resource.

#### Set the name of the resource (2)

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

Set the name of the resource.

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

**Parameters**

The name of the resource.

#### Const

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]

#### Set the fragment of the resource

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

Set the fragment of the resource.

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

**Parameters**

The pointer to the fragment of the resource.

#### Get a pointer to \[Fragment]\(fragment) object

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

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

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

#### Const

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]

#### Set the component specification to the resource

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

Set the component specification to the resource.

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

**Parameters**

The component specification.

#### Get the component specification of the resource

```cpp showLineNumbers={false}
ComponentSpec * holoscan::DataLoggerResource::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::DataLoggerResource::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::DataLoggerResource::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::DataLoggerResource::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]

#### Add an argument to the component (1)

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

Add an argument to the component.

**Parameters**

The argument to add.

#### Add an argument to the component (2)

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

Add an argument to the component.

**Parameters**

The argument to add.

#### Add a list of arguments to the component (1)

```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.

#### Add a list of arguments to the component (2)

```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).

### compile\_patterns \[#compilepatterns]

```cpp showLineNumbers={false}
void holoscan::DataLoggerResource::compile_patterns()
```

Compiles string patterns into regex objects for efficient matching.

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

#### Update parameters based on the specified arguments

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

Update parameters based on the specified arguments.

#### Update parameters based on the specified arguments (with params)

```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                                       |
| ----------------------------- | ------------------------------------------------------ | ------------------------------------------------- |
| `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.                  |
| `compiled_allowlist_pattern_` | `std::optional< std::regex >`                          |                                                   |
| `compiled_denylist_pattern_`  | `std::optional< std::regex >`                          |                                                   |
| `patterns_compiled_`          | `bool`                                                 |                                                   |
| `time_reference_`             | `std::chrono::time_point< std::chrono::steady_clock >` |                                                   |
| `time_offset_`                | `int64_t`                                              |                                                   |