ROS Index
Repository Summary
| Checkout URI | https://github.com/nobleo/ros2_fmt_logger.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-08-24 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| ros2_fmt_logger | 1.1.0 |
README
ros2_fmt_logger
A modern, ROS 2 logging library that provides fmt-style formatting as a replacement for RCLCPP logging macros.
Features
- Function calls instead of macros:
logger.info("Hello, {}!", name)instead ofRCLCPP_INFO(logger, "Hello, %s", name.c_str()) - Additional
.on_change()method for logging changes in values - Chrono syntax for throttling:
logger.warn_throttle(1s, "Warning: {}", value) - Backwards compatible with the macros, so easy to start using in existing projects without a full rewrite of the current log statements
Examples
Once-only logging
logger.info_once("This message will only appear once, no matter how many times called");
Throttled logging
using std::chrono_literals::operator""s;
logger.warn_throttle(1s, "This warning appears at most once per second: {}", value);
Change-based logging
// Log only when the value changes
logger.info_on_change(sensor_value, "Sensor reading changed to: {}", sensor_value);
// Log only when change exceeds threshold
logger.error_on_change(temperature, 5.0, "Temperature changed significantly: {:.1f}°C", temperature);
Quick Start
Include in the package.xml
<depend>ros2_fmt_logger</depend>
Configure c++20 and find_package
find_package(ros2_fmt_logger REQUIRED)
target_link_libraries(your_target ros2_fmt_logger::ros2_fmt_logger)
Include the header
#include <ros2_fmt_logger/logger.hpp>
Create a logger instance
// From an rclcpp::Logger
auto logger = ros2_fmt_logger::Logger(node->get_logger());
// With custom clock for throttling features
auto logger = ros2_fmt_logger::Logger(node->get_logger(), node->get_clock());
3. Use modern logging syntax
// Instead of: RCLCPP_INFO(logger, "Processing item %d with value %.2f", id, value);
logger.info("Processing item {} with value {:.2f}", id, value);
// Instead of: RCLCPP_ERROR(logger, "Failed to connect to %s:%d", host.c_str(), port);
logger.error("Failed to connect to {}:{}", host, port);
Format String Syntax
Uses the powerful fmt library format syntax:
```cpp // Basic formatting logger.info(“Hello, {}!”, name);
// Positional arguments logger.info(“Processing {1} of {0} items”, total, current);
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/nobleo/ros2_fmt_logger.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-08-24 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| ros2_fmt_logger | 1.1.0 |
README
ros2_fmt_logger
A modern, ROS 2 logging library that provides fmt-style formatting as a replacement for RCLCPP logging macros.
Features
- Function calls instead of macros:
logger.info("Hello, {}!", name)instead ofRCLCPP_INFO(logger, "Hello, %s", name.c_str()) - Additional
.on_change()method for logging changes in values - Chrono syntax for throttling:
logger.warn_throttle(1s, "Warning: {}", value) - Backwards compatible with the macros, so easy to start using in existing projects without a full rewrite of the current log statements
Examples
Once-only logging
logger.info_once("This message will only appear once, no matter how many times called");
Throttled logging
using std::chrono_literals::operator""s;
logger.warn_throttle(1s, "This warning appears at most once per second: {}", value);
Change-based logging
// Log only when the value changes
logger.info_on_change(sensor_value, "Sensor reading changed to: {}", sensor_value);
// Log only when change exceeds threshold
logger.error_on_change(temperature, 5.0, "Temperature changed significantly: {:.1f}°C", temperature);
Quick Start
Include in the package.xml
<depend>ros2_fmt_logger</depend>
Configure c++20 and find_package
find_package(ros2_fmt_logger REQUIRED)
target_link_libraries(your_target ros2_fmt_logger::ros2_fmt_logger)
Include the header
#include <ros2_fmt_logger/logger.hpp>
Create a logger instance
// From an rclcpp::Logger
auto logger = ros2_fmt_logger::Logger(node->get_logger());
// With custom clock for throttling features
auto logger = ros2_fmt_logger::Logger(node->get_logger(), node->get_clock());
3. Use modern logging syntax
// Instead of: RCLCPP_INFO(logger, "Processing item %d with value %.2f", id, value);
logger.info("Processing item {} with value {:.2f}", id, value);
// Instead of: RCLCPP_ERROR(logger, "Failed to connect to %s:%d", host.c_str(), port);
logger.error("Failed to connect to {}:{}", host, port);
Format String Syntax
Uses the powerful fmt library format syntax:
```cpp // Basic formatting logger.info(“Hello, {}!”, name);
// Positional arguments logger.info(“Processing {1} of {0} items”, total, current);
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/nobleo/ros2_fmt_logger.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-08-24 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| ros2_fmt_logger | 1.1.0 |
README
ros2_fmt_logger
A modern, ROS 2 logging library that provides fmt-style formatting as a replacement for RCLCPP logging macros.
Features
- Function calls instead of macros:
logger.info("Hello, {}!", name)instead ofRCLCPP_INFO(logger, "Hello, %s", name.c_str()) - Additional
.on_change()method for logging changes in values - Chrono syntax for throttling:
logger.warn_throttle(1s, "Warning: {}", value) - Backwards compatible with the macros, so easy to start using in existing projects without a full rewrite of the current log statements
Examples
Once-only logging
logger.info_once("This message will only appear once, no matter how many times called");
Throttled logging
using std::chrono_literals::operator""s;
logger.warn_throttle(1s, "This warning appears at most once per second: {}", value);
Change-based logging
// Log only when the value changes
logger.info_on_change(sensor_value, "Sensor reading changed to: {}", sensor_value);
// Log only when change exceeds threshold
logger.error_on_change(temperature, 5.0, "Temperature changed significantly: {:.1f}°C", temperature);
Quick Start
Include in the package.xml
<depend>ros2_fmt_logger</depend>
Configure c++20 and find_package
find_package(ros2_fmt_logger REQUIRED)
target_link_libraries(your_target ros2_fmt_logger::ros2_fmt_logger)
Include the header
#include <ros2_fmt_logger/logger.hpp>
Create a logger instance
// From an rclcpp::Logger
auto logger = ros2_fmt_logger::Logger(node->get_logger());
// With custom clock for throttling features
auto logger = ros2_fmt_logger::Logger(node->get_logger(), node->get_clock());
3. Use modern logging syntax
// Instead of: RCLCPP_INFO(logger, "Processing item %d with value %.2f", id, value);
logger.info("Processing item {} with value {:.2f}", id, value);
// Instead of: RCLCPP_ERROR(logger, "Failed to connect to %s:%d", host.c_str(), port);
logger.error("Failed to connect to {}:{}", host, port);
Format String Syntax
Uses the powerful fmt library format syntax:
```cpp // Basic formatting logger.info(“Hello, {}!”, name);
// Positional arguments logger.info(“Processing {1} of {0} items”, total, current);
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/nobleo/ros2_fmt_logger.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-08-24 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| ros2_fmt_logger | 1.1.0 |
README
ros2_fmt_logger
A modern, ROS 2 logging library that provides fmt-style formatting as a replacement for RCLCPP logging macros.
Features
- Function calls instead of macros:
logger.info("Hello, {}!", name)instead ofRCLCPP_INFO(logger, "Hello, %s", name.c_str()) - Additional
.on_change()method for logging changes in values - Chrono syntax for throttling:
logger.warn_throttle(1s, "Warning: {}", value) - Backwards compatible with the macros, so easy to start using in existing projects without a full rewrite of the current log statements
Examples
Once-only logging
logger.info_once("This message will only appear once, no matter how many times called");
Throttled logging
using std::chrono_literals::operator""s;
logger.warn_throttle(1s, "This warning appears at most once per second: {}", value);
Change-based logging
// Log only when the value changes
logger.info_on_change(sensor_value, "Sensor reading changed to: {}", sensor_value);
// Log only when change exceeds threshold
logger.error_on_change(temperature, 5.0, "Temperature changed significantly: {:.1f}°C", temperature);
Quick Start
Include in the package.xml
<depend>ros2_fmt_logger</depend>
Configure c++20 and find_package
find_package(ros2_fmt_logger REQUIRED)
target_link_libraries(your_target ros2_fmt_logger::ros2_fmt_logger)
Include the header
#include <ros2_fmt_logger/logger.hpp>
Create a logger instance
// From an rclcpp::Logger
auto logger = ros2_fmt_logger::Logger(node->get_logger());
// With custom clock for throttling features
auto logger = ros2_fmt_logger::Logger(node->get_logger(), node->get_clock());
3. Use modern logging syntax
// Instead of: RCLCPP_INFO(logger, "Processing item %d with value %.2f", id, value);
logger.info("Processing item {} with value {:.2f}", id, value);
// Instead of: RCLCPP_ERROR(logger, "Failed to connect to %s:%d", host.c_str(), port);
logger.error("Failed to connect to {}:{}", host, port);
Format String Syntax
Uses the powerful fmt library format syntax:
```cpp // Basic formatting logger.info(“Hello, {}!”, name);
// Positional arguments logger.info(“Processing {1} of {0} items”, total, current);
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/nobleo/ros2_fmt_logger.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-08-24 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| ros2_fmt_logger | 1.1.0 |
README
ros2_fmt_logger
A modern, ROS 2 logging library that provides fmt-style formatting as a replacement for RCLCPP logging macros.
Features
- Function calls instead of macros:
logger.info("Hello, {}!", name)instead ofRCLCPP_INFO(logger, "Hello, %s", name.c_str()) - Additional
.on_change()method for logging changes in values - Chrono syntax for throttling:
logger.warn_throttle(1s, "Warning: {}", value) - Backwards compatible with the macros, so easy to start using in existing projects without a full rewrite of the current log statements
Examples
Once-only logging
logger.info_once("This message will only appear once, no matter how many times called");
Throttled logging
using std::chrono_literals::operator""s;
logger.warn_throttle(1s, "This warning appears at most once per second: {}", value);
Change-based logging
// Log only when the value changes
logger.info_on_change(sensor_value, "Sensor reading changed to: {}", sensor_value);
// Log only when change exceeds threshold
logger.error_on_change(temperature, 5.0, "Temperature changed significantly: {:.1f}°C", temperature);
Quick Start
Include in the package.xml
<depend>ros2_fmt_logger</depend>
Configure c++20 and find_package
find_package(ros2_fmt_logger REQUIRED)
target_link_libraries(your_target ros2_fmt_logger::ros2_fmt_logger)
Include the header
#include <ros2_fmt_logger/logger.hpp>
Create a logger instance
// From an rclcpp::Logger
auto logger = ros2_fmt_logger::Logger(node->get_logger());
// With custom clock for throttling features
auto logger = ros2_fmt_logger::Logger(node->get_logger(), node->get_clock());
3. Use modern logging syntax
// Instead of: RCLCPP_INFO(logger, "Processing item %d with value %.2f", id, value);
logger.info("Processing item {} with value {:.2f}", id, value);
// Instead of: RCLCPP_ERROR(logger, "Failed to connect to %s:%d", host.c_str(), port);
logger.error("Failed to connect to {}:{}", host, port);
Format String Syntax
Uses the powerful fmt library format syntax:
```cpp // Basic formatting logger.info(“Hello, {}!”, name);
// Positional arguments logger.info(“Processing {1} of {0} items”, total, current);
File truncated at 100 lines see the full file
CONTRIBUTING
No version for distro ardent showing humble. Known supported distros are highlighted in the buttons above.
Repository Summary
| Checkout URI | https://github.com/nobleo/ros2_fmt_logger.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-08-24 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| ros2_fmt_logger | 1.1.0 |
README
ros2_fmt_logger
A modern, ROS 2 logging library that provides fmt-style formatting as a replacement for RCLCPP logging macros.
Features
- Function calls instead of macros:
logger.info("Hello, {}!", name)instead ofRCLCPP_INFO(logger, "Hello, %s", name.c_str()) - Additional
.on_change()method for logging changes in values - Chrono syntax for throttling:
logger.warn_throttle(1s, "Warning: {}", value) - Backwards compatible with the macros, so easy to start using in existing projects without a full rewrite of the current log statements
Examples
Once-only logging
logger.info_once("This message will only appear once, no matter how many times called");
Throttled logging
using std::chrono_literals::operator""s;
logger.warn_throttle(1s, "This warning appears at most once per second: {}", value);
Change-based logging
// Log only when the value changes
logger.info_on_change(sensor_value, "Sensor reading changed to: {}", sensor_value);
// Log only when change exceeds threshold
logger.error_on_change(temperature, 5.0, "Temperature changed significantly: {:.1f}°C", temperature);
Quick Start
Include in the package.xml
<depend>ros2_fmt_logger</depend>
Configure c++20 and find_package
find_package(ros2_fmt_logger REQUIRED)
target_link_libraries(your_target ros2_fmt_logger::ros2_fmt_logger)
Include the header
#include <ros2_fmt_logger/logger.hpp>
Create a logger instance
// From an rclcpp::Logger
auto logger = ros2_fmt_logger::Logger(node->get_logger());
// With custom clock for throttling features
auto logger = ros2_fmt_logger::Logger(node->get_logger(), node->get_clock());
3. Use modern logging syntax
// Instead of: RCLCPP_INFO(logger, "Processing item %d with value %.2f", id, value);
logger.info("Processing item {} with value {:.2f}", id, value);
// Instead of: RCLCPP_ERROR(logger, "Failed to connect to %s:%d", host.c_str(), port);
logger.error("Failed to connect to {}:{}", host, port);
Format String Syntax
Uses the powerful fmt library format syntax:
```cpp // Basic formatting logger.info(“Hello, {}!”, name);
// Positional arguments logger.info(“Processing {1} of {0} items”, total, current);
File truncated at 100 lines see the full file
CONTRIBUTING
No version for distro bouncy showing humble. Known supported distros are highlighted in the buttons above.
Repository Summary
| Checkout URI | https://github.com/nobleo/ros2_fmt_logger.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-08-24 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| ros2_fmt_logger | 1.1.0 |
README
ros2_fmt_logger
A modern, ROS 2 logging library that provides fmt-style formatting as a replacement for RCLCPP logging macros.
Features
- Function calls instead of macros:
logger.info("Hello, {}!", name)instead ofRCLCPP_INFO(logger, "Hello, %s", name.c_str()) - Additional
.on_change()method for logging changes in values - Chrono syntax for throttling:
logger.warn_throttle(1s, "Warning: {}", value) - Backwards compatible with the macros, so easy to start using in existing projects without a full rewrite of the current log statements
Examples
Once-only logging
logger.info_once("This message will only appear once, no matter how many times called");
Throttled logging
using std::chrono_literals::operator""s;
logger.warn_throttle(1s, "This warning appears at most once per second: {}", value);
Change-based logging
// Log only when the value changes
logger.info_on_change(sensor_value, "Sensor reading changed to: {}", sensor_value);
// Log only when change exceeds threshold
logger.error_on_change(temperature, 5.0, "Temperature changed significantly: {:.1f}°C", temperature);
Quick Start
Include in the package.xml
<depend>ros2_fmt_logger</depend>
Configure c++20 and find_package
find_package(ros2_fmt_logger REQUIRED)
target_link_libraries(your_target ros2_fmt_logger::ros2_fmt_logger)
Include the header
#include <ros2_fmt_logger/logger.hpp>
Create a logger instance
// From an rclcpp::Logger
auto logger = ros2_fmt_logger::Logger(node->get_logger());
// With custom clock for throttling features
auto logger = ros2_fmt_logger::Logger(node->get_logger(), node->get_clock());
3. Use modern logging syntax
// Instead of: RCLCPP_INFO(logger, "Processing item %d with value %.2f", id, value);
logger.info("Processing item {} with value {:.2f}", id, value);
// Instead of: RCLCPP_ERROR(logger, "Failed to connect to %s:%d", host.c_str(), port);
logger.error("Failed to connect to {}:{}", host, port);
Format String Syntax
Uses the powerful fmt library format syntax:
```cpp // Basic formatting logger.info(“Hello, {}!”, name);
// Positional arguments logger.info(“Processing {1} of {0} items”, total, current);
File truncated at 100 lines see the full file
CONTRIBUTING
No version for distro crystal showing humble. Known supported distros are highlighted in the buttons above.
Repository Summary
| Checkout URI | https://github.com/nobleo/ros2_fmt_logger.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-08-24 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| ros2_fmt_logger | 1.1.0 |
README
ros2_fmt_logger
A modern, ROS 2 logging library that provides fmt-style formatting as a replacement for RCLCPP logging macros.
Features
- Function calls instead of macros:
logger.info("Hello, {}!", name)instead ofRCLCPP_INFO(logger, "Hello, %s", name.c_str()) - Additional
.on_change()method for logging changes in values - Chrono syntax for throttling:
logger.warn_throttle(1s, "Warning: {}", value) - Backwards compatible with the macros, so easy to start using in existing projects without a full rewrite of the current log statements
Examples
Once-only logging
logger.info_once("This message will only appear once, no matter how many times called");
Throttled logging
using std::chrono_literals::operator""s;
logger.warn_throttle(1s, "This warning appears at most once per second: {}", value);
Change-based logging
// Log only when the value changes
logger.info_on_change(sensor_value, "Sensor reading changed to: {}", sensor_value);
// Log only when change exceeds threshold
logger.error_on_change(temperature, 5.0, "Temperature changed significantly: {:.1f}°C", temperature);
Quick Start
Include in the package.xml
<depend>ros2_fmt_logger</depend>
Configure c++20 and find_package
find_package(ros2_fmt_logger REQUIRED)
target_link_libraries(your_target ros2_fmt_logger::ros2_fmt_logger)
Include the header
#include <ros2_fmt_logger/logger.hpp>
Create a logger instance
// From an rclcpp::Logger
auto logger = ros2_fmt_logger::Logger(node->get_logger());
// With custom clock for throttling features
auto logger = ros2_fmt_logger::Logger(node->get_logger(), node->get_clock());
3. Use modern logging syntax
// Instead of: RCLCPP_INFO(logger, "Processing item %d with value %.2f", id, value);
logger.info("Processing item {} with value {:.2f}", id, value);
// Instead of: RCLCPP_ERROR(logger, "Failed to connect to %s:%d", host.c_str(), port);
logger.error("Failed to connect to {}:{}", host, port);
Format String Syntax
Uses the powerful fmt library format syntax:
```cpp // Basic formatting logger.info(“Hello, {}!”, name);
// Positional arguments logger.info(“Processing {1} of {0} items”, total, current);
File truncated at 100 lines see the full file
CONTRIBUTING
No version for distro eloquent showing humble. Known supported distros are highlighted in the buttons above.
Repository Summary
| Checkout URI | https://github.com/nobleo/ros2_fmt_logger.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-08-24 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| ros2_fmt_logger | 1.1.0 |
README
ros2_fmt_logger
A modern, ROS 2 logging library that provides fmt-style formatting as a replacement for RCLCPP logging macros.
Features
- Function calls instead of macros:
logger.info("Hello, {}!", name)instead ofRCLCPP_INFO(logger, "Hello, %s", name.c_str()) - Additional
.on_change()method for logging changes in values - Chrono syntax for throttling:
logger.warn_throttle(1s, "Warning: {}", value) - Backwards compatible with the macros, so easy to start using in existing projects without a full rewrite of the current log statements
Examples
Once-only logging
logger.info_once("This message will only appear once, no matter how many times called");
Throttled logging
using std::chrono_literals::operator""s;
logger.warn_throttle(1s, "This warning appears at most once per second: {}", value);
Change-based logging
// Log only when the value changes
logger.info_on_change(sensor_value, "Sensor reading changed to: {}", sensor_value);
// Log only when change exceeds threshold
logger.error_on_change(temperature, 5.0, "Temperature changed significantly: {:.1f}°C", temperature);
Quick Start
Include in the package.xml
<depend>ros2_fmt_logger</depend>
Configure c++20 and find_package
find_package(ros2_fmt_logger REQUIRED)
target_link_libraries(your_target ros2_fmt_logger::ros2_fmt_logger)
Include the header
#include <ros2_fmt_logger/logger.hpp>
Create a logger instance
// From an rclcpp::Logger
auto logger = ros2_fmt_logger::Logger(node->get_logger());
// With custom clock for throttling features
auto logger = ros2_fmt_logger::Logger(node->get_logger(), node->get_clock());
3. Use modern logging syntax
// Instead of: RCLCPP_INFO(logger, "Processing item %d with value %.2f", id, value);
logger.info("Processing item {} with value {:.2f}", id, value);
// Instead of: RCLCPP_ERROR(logger, "Failed to connect to %s:%d", host.c_str(), port);
logger.error("Failed to connect to {}:{}", host, port);
Format String Syntax
Uses the powerful fmt library format syntax:
```cpp // Basic formatting logger.info(“Hello, {}!”, name);
// Positional arguments logger.info(“Processing {1} of {0} items”, total, current);
File truncated at 100 lines see the full file
CONTRIBUTING
No version for distro dashing showing humble. Known supported distros are highlighted in the buttons above.
Repository Summary
| Checkout URI | https://github.com/nobleo/ros2_fmt_logger.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-08-24 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| ros2_fmt_logger | 1.1.0 |
README
ros2_fmt_logger
A modern, ROS 2 logging library that provides fmt-style formatting as a replacement for RCLCPP logging macros.
Features
- Function calls instead of macros:
logger.info("Hello, {}!", name)instead ofRCLCPP_INFO(logger, "Hello, %s", name.c_str()) - Additional
.on_change()method for logging changes in values - Chrono syntax for throttling:
logger.warn_throttle(1s, "Warning: {}", value) - Backwards compatible with the macros, so easy to start using in existing projects without a full rewrite of the current log statements
Examples
Once-only logging
logger.info_once("This message will only appear once, no matter how many times called");
Throttled logging
using std::chrono_literals::operator""s;
logger.warn_throttle(1s, "This warning appears at most once per second: {}", value);
Change-based logging
// Log only when the value changes
logger.info_on_change(sensor_value, "Sensor reading changed to: {}", sensor_value);
// Log only when change exceeds threshold
logger.error_on_change(temperature, 5.0, "Temperature changed significantly: {:.1f}°C", temperature);
Quick Start
Include in the package.xml
<depend>ros2_fmt_logger</depend>
Configure c++20 and find_package
find_package(ros2_fmt_logger REQUIRED)
target_link_libraries(your_target ros2_fmt_logger::ros2_fmt_logger)
Include the header
#include <ros2_fmt_logger/logger.hpp>
Create a logger instance
// From an rclcpp::Logger
auto logger = ros2_fmt_logger::Logger(node->get_logger());
// With custom clock for throttling features
auto logger = ros2_fmt_logger::Logger(node->get_logger(), node->get_clock());
3. Use modern logging syntax
// Instead of: RCLCPP_INFO(logger, "Processing item %d with value %.2f", id, value);
logger.info("Processing item {} with value {:.2f}", id, value);
// Instead of: RCLCPP_ERROR(logger, "Failed to connect to %s:%d", host.c_str(), port);
logger.error("Failed to connect to {}:{}", host, port);
Format String Syntax
Uses the powerful fmt library format syntax:
```cpp // Basic formatting logger.info(“Hello, {}!”, name);
// Positional arguments logger.info(“Processing {1} of {0} items”, total, current);
File truncated at 100 lines see the full file
CONTRIBUTING
No version for distro galactic showing humble. Known supported distros are highlighted in the buttons above.
Repository Summary
| Checkout URI | https://github.com/nobleo/ros2_fmt_logger.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-08-24 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| ros2_fmt_logger | 1.1.0 |
README
ros2_fmt_logger
A modern, ROS 2 logging library that provides fmt-style formatting as a replacement for RCLCPP logging macros.
Features
- Function calls instead of macros:
logger.info("Hello, {}!", name)instead ofRCLCPP_INFO(logger, "Hello, %s", name.c_str()) - Additional
.on_change()method for logging changes in values - Chrono syntax for throttling:
logger.warn_throttle(1s, "Warning: {}", value) - Backwards compatible with the macros, so easy to start using in existing projects without a full rewrite of the current log statements
Examples
Once-only logging
logger.info_once("This message will only appear once, no matter how many times called");
Throttled logging
using std::chrono_literals::operator""s;
logger.warn_throttle(1s, "This warning appears at most once per second: {}", value);
Change-based logging
// Log only when the value changes
logger.info_on_change(sensor_value, "Sensor reading changed to: {}", sensor_value);
// Log only when change exceeds threshold
logger.error_on_change(temperature, 5.0, "Temperature changed significantly: {:.1f}°C", temperature);
Quick Start
Include in the package.xml
<depend>ros2_fmt_logger</depend>
Configure c++20 and find_package
find_package(ros2_fmt_logger REQUIRED)
target_link_libraries(your_target ros2_fmt_logger::ros2_fmt_logger)
Include the header
#include <ros2_fmt_logger/logger.hpp>
Create a logger instance
// From an rclcpp::Logger
auto logger = ros2_fmt_logger::Logger(node->get_logger());
// With custom clock for throttling features
auto logger = ros2_fmt_logger::Logger(node->get_logger(), node->get_clock());
3. Use modern logging syntax
// Instead of: RCLCPP_INFO(logger, "Processing item %d with value %.2f", id, value);
logger.info("Processing item {} with value {:.2f}", id, value);
// Instead of: RCLCPP_ERROR(logger, "Failed to connect to %s:%d", host.c_str(), port);
logger.error("Failed to connect to {}:{}", host, port);
Format String Syntax
Uses the powerful fmt library format syntax:
```cpp // Basic formatting logger.info(“Hello, {}!”, name);
// Positional arguments logger.info(“Processing {1} of {0} items”, total, current);
File truncated at 100 lines see the full file
CONTRIBUTING
No version for distro foxy showing humble. Known supported distros are highlighted in the buttons above.
Repository Summary
| Checkout URI | https://github.com/nobleo/ros2_fmt_logger.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-08-24 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| ros2_fmt_logger | 1.1.0 |
README
ros2_fmt_logger
A modern, ROS 2 logging library that provides fmt-style formatting as a replacement for RCLCPP logging macros.
Features
- Function calls instead of macros:
logger.info("Hello, {}!", name)instead ofRCLCPP_INFO(logger, "Hello, %s", name.c_str()) - Additional
.on_change()method for logging changes in values - Chrono syntax for throttling:
logger.warn_throttle(1s, "Warning: {}", value) - Backwards compatible with the macros, so easy to start using in existing projects without a full rewrite of the current log statements
Examples
Once-only logging
logger.info_once("This message will only appear once, no matter how many times called");
Throttled logging
using std::chrono_literals::operator""s;
logger.warn_throttle(1s, "This warning appears at most once per second: {}", value);
Change-based logging
// Log only when the value changes
logger.info_on_change(sensor_value, "Sensor reading changed to: {}", sensor_value);
// Log only when change exceeds threshold
logger.error_on_change(temperature, 5.0, "Temperature changed significantly: {:.1f}°C", temperature);
Quick Start
Include in the package.xml
<depend>ros2_fmt_logger</depend>
Configure c++20 and find_package
find_package(ros2_fmt_logger REQUIRED)
target_link_libraries(your_target ros2_fmt_logger::ros2_fmt_logger)
Include the header
#include <ros2_fmt_logger/logger.hpp>
Create a logger instance
// From an rclcpp::Logger
auto logger = ros2_fmt_logger::Logger(node->get_logger());
// With custom clock for throttling features
auto logger = ros2_fmt_logger::Logger(node->get_logger(), node->get_clock());
3. Use modern logging syntax
// Instead of: RCLCPP_INFO(logger, "Processing item %d with value %.2f", id, value);
logger.info("Processing item {} with value {:.2f}", id, value);
// Instead of: RCLCPP_ERROR(logger, "Failed to connect to %s:%d", host.c_str(), port);
logger.error("Failed to connect to {}:{}", host, port);
Format String Syntax
Uses the powerful fmt library format syntax:
```cpp // Basic formatting logger.info(“Hello, {}!”, name);
// Positional arguments logger.info(“Processing {1} of {0} items”, total, current);
File truncated at 100 lines see the full file
CONTRIBUTING
No version for distro iron showing humble. Known supported distros are highlighted in the buttons above.
Repository Summary
| Checkout URI | https://github.com/nobleo/ros2_fmt_logger.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-08-24 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| ros2_fmt_logger | 1.1.0 |
README
ros2_fmt_logger
A modern, ROS 2 logging library that provides fmt-style formatting as a replacement for RCLCPP logging macros.
Features
- Function calls instead of macros:
logger.info("Hello, {}!", name)instead ofRCLCPP_INFO(logger, "Hello, %s", name.c_str()) - Additional
.on_change()method for logging changes in values - Chrono syntax for throttling:
logger.warn_throttle(1s, "Warning: {}", value) - Backwards compatible with the macros, so easy to start using in existing projects without a full rewrite of the current log statements
Examples
Once-only logging
logger.info_once("This message will only appear once, no matter how many times called");
Throttled logging
using std::chrono_literals::operator""s;
logger.warn_throttle(1s, "This warning appears at most once per second: {}", value);
Change-based logging
// Log only when the value changes
logger.info_on_change(sensor_value, "Sensor reading changed to: {}", sensor_value);
// Log only when change exceeds threshold
logger.error_on_change(temperature, 5.0, "Temperature changed significantly: {:.1f}°C", temperature);
Quick Start
Include in the package.xml
<depend>ros2_fmt_logger</depend>
Configure c++20 and find_package
find_package(ros2_fmt_logger REQUIRED)
target_link_libraries(your_target ros2_fmt_logger::ros2_fmt_logger)
Include the header
#include <ros2_fmt_logger/logger.hpp>
Create a logger instance
// From an rclcpp::Logger
auto logger = ros2_fmt_logger::Logger(node->get_logger());
// With custom clock for throttling features
auto logger = ros2_fmt_logger::Logger(node->get_logger(), node->get_clock());
3. Use modern logging syntax
// Instead of: RCLCPP_INFO(logger, "Processing item %d with value %.2f", id, value);
logger.info("Processing item {} with value {:.2f}", id, value);
// Instead of: RCLCPP_ERROR(logger, "Failed to connect to %s:%d", host.c_str(), port);
logger.error("Failed to connect to {}:{}", host, port);
Format String Syntax
Uses the powerful fmt library format syntax:
```cpp // Basic formatting logger.info(“Hello, {}!”, name);
// Positional arguments logger.info(“Processing {1} of {0} items”, total, current);
File truncated at 100 lines see the full file
CONTRIBUTING
No version for distro lunar showing humble. Known supported distros are highlighted in the buttons above.
Repository Summary
| Checkout URI | https://github.com/nobleo/ros2_fmt_logger.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-08-24 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| ros2_fmt_logger | 1.1.0 |
README
ros2_fmt_logger
A modern, ROS 2 logging library that provides fmt-style formatting as a replacement for RCLCPP logging macros.
Features
- Function calls instead of macros:
logger.info("Hello, {}!", name)instead ofRCLCPP_INFO(logger, "Hello, %s", name.c_str()) - Additional
.on_change()method for logging changes in values - Chrono syntax for throttling:
logger.warn_throttle(1s, "Warning: {}", value) - Backwards compatible with the macros, so easy to start using in existing projects without a full rewrite of the current log statements
Examples
Once-only logging
logger.info_once("This message will only appear once, no matter how many times called");
Throttled logging
using std::chrono_literals::operator""s;
logger.warn_throttle(1s, "This warning appears at most once per second: {}", value);
Change-based logging
// Log only when the value changes
logger.info_on_change(sensor_value, "Sensor reading changed to: {}", sensor_value);
// Log only when change exceeds threshold
logger.error_on_change(temperature, 5.0, "Temperature changed significantly: {:.1f}°C", temperature);
Quick Start
Include in the package.xml
<depend>ros2_fmt_logger</depend>
Configure c++20 and find_package
find_package(ros2_fmt_logger REQUIRED)
target_link_libraries(your_target ros2_fmt_logger::ros2_fmt_logger)
Include the header
#include <ros2_fmt_logger/logger.hpp>
Create a logger instance
// From an rclcpp::Logger
auto logger = ros2_fmt_logger::Logger(node->get_logger());
// With custom clock for throttling features
auto logger = ros2_fmt_logger::Logger(node->get_logger(), node->get_clock());
3. Use modern logging syntax
// Instead of: RCLCPP_INFO(logger, "Processing item %d with value %.2f", id, value);
logger.info("Processing item {} with value {:.2f}", id, value);
// Instead of: RCLCPP_ERROR(logger, "Failed to connect to %s:%d", host.c_str(), port);
logger.error("Failed to connect to {}:{}", host, port);
Format String Syntax
Uses the powerful fmt library format syntax:
```cpp // Basic formatting logger.info(“Hello, {}!”, name);
// Positional arguments logger.info(“Processing {1} of {0} items”, total, current);
File truncated at 100 lines see the full file
CONTRIBUTING
No version for distro jade showing humble. Known supported distros are highlighted in the buttons above.
Repository Summary
| Checkout URI | https://github.com/nobleo/ros2_fmt_logger.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-08-24 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| ros2_fmt_logger | 1.1.0 |
README
ros2_fmt_logger
A modern, ROS 2 logging library that provides fmt-style formatting as a replacement for RCLCPP logging macros.
Features
- Function calls instead of macros:
logger.info("Hello, {}!", name)instead ofRCLCPP_INFO(logger, "Hello, %s", name.c_str()) - Additional
.on_change()method for logging changes in values - Chrono syntax for throttling:
logger.warn_throttle(1s, "Warning: {}", value) - Backwards compatible with the macros, so easy to start using in existing projects without a full rewrite of the current log statements
Examples
Once-only logging
logger.info_once("This message will only appear once, no matter how many times called");
Throttled logging
using std::chrono_literals::operator""s;
logger.warn_throttle(1s, "This warning appears at most once per second: {}", value);
Change-based logging
// Log only when the value changes
logger.info_on_change(sensor_value, "Sensor reading changed to: {}", sensor_value);
// Log only when change exceeds threshold
logger.error_on_change(temperature, 5.0, "Temperature changed significantly: {:.1f}°C", temperature);
Quick Start
Include in the package.xml
<depend>ros2_fmt_logger</depend>
Configure c++20 and find_package
find_package(ros2_fmt_logger REQUIRED)
target_link_libraries(your_target ros2_fmt_logger::ros2_fmt_logger)
Include the header
#include <ros2_fmt_logger/logger.hpp>
Create a logger instance
// From an rclcpp::Logger
auto logger = ros2_fmt_logger::Logger(node->get_logger());
// With custom clock for throttling features
auto logger = ros2_fmt_logger::Logger(node->get_logger(), node->get_clock());
3. Use modern logging syntax
// Instead of: RCLCPP_INFO(logger, "Processing item %d with value %.2f", id, value);
logger.info("Processing item {} with value {:.2f}", id, value);
// Instead of: RCLCPP_ERROR(logger, "Failed to connect to %s:%d", host.c_str(), port);
logger.error("Failed to connect to {}:{}", host, port);
Format String Syntax
Uses the powerful fmt library format syntax:
```cpp // Basic formatting logger.info(“Hello, {}!”, name);
// Positional arguments logger.info(“Processing {1} of {0} items”, total, current);
File truncated at 100 lines see the full file
CONTRIBUTING
No version for distro indigo showing humble. Known supported distros are highlighted in the buttons above.
Repository Summary
| Checkout URI | https://github.com/nobleo/ros2_fmt_logger.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-08-24 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| ros2_fmt_logger | 1.1.0 |
README
ros2_fmt_logger
A modern, ROS 2 logging library that provides fmt-style formatting as a replacement for RCLCPP logging macros.
Features
- Function calls instead of macros:
logger.info("Hello, {}!", name)instead ofRCLCPP_INFO(logger, "Hello, %s", name.c_str()) - Additional
.on_change()method for logging changes in values - Chrono syntax for throttling:
logger.warn_throttle(1s, "Warning: {}", value) - Backwards compatible with the macros, so easy to start using in existing projects without a full rewrite of the current log statements
Examples
Once-only logging
logger.info_once("This message will only appear once, no matter how many times called");
Throttled logging
using std::chrono_literals::operator""s;
logger.warn_throttle(1s, "This warning appears at most once per second: {}", value);
Change-based logging
// Log only when the value changes
logger.info_on_change(sensor_value, "Sensor reading changed to: {}", sensor_value);
// Log only when change exceeds threshold
logger.error_on_change(temperature, 5.0, "Temperature changed significantly: {:.1f}°C", temperature);
Quick Start
Include in the package.xml
<depend>ros2_fmt_logger</depend>
Configure c++20 and find_package
find_package(ros2_fmt_logger REQUIRED)
target_link_libraries(your_target ros2_fmt_logger::ros2_fmt_logger)
Include the header
#include <ros2_fmt_logger/logger.hpp>
Create a logger instance
// From an rclcpp::Logger
auto logger = ros2_fmt_logger::Logger(node->get_logger());
// With custom clock for throttling features
auto logger = ros2_fmt_logger::Logger(node->get_logger(), node->get_clock());
3. Use modern logging syntax
// Instead of: RCLCPP_INFO(logger, "Processing item %d with value %.2f", id, value);
logger.info("Processing item {} with value {:.2f}", id, value);
// Instead of: RCLCPP_ERROR(logger, "Failed to connect to %s:%d", host.c_str(), port);
logger.error("Failed to connect to {}:{}", host, port);
Format String Syntax
Uses the powerful fmt library format syntax:
```cpp // Basic formatting logger.info(“Hello, {}!”, name);
// Positional arguments logger.info(“Processing {1} of {0} items”, total, current);
File truncated at 100 lines see the full file
CONTRIBUTING
No version for distro hydro showing humble. Known supported distros are highlighted in the buttons above.
Repository Summary
| Checkout URI | https://github.com/nobleo/ros2_fmt_logger.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-08-24 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| ros2_fmt_logger | 1.1.0 |
README
ros2_fmt_logger
A modern, ROS 2 logging library that provides fmt-style formatting as a replacement for RCLCPP logging macros.
Features
- Function calls instead of macros:
logger.info("Hello, {}!", name)instead ofRCLCPP_INFO(logger, "Hello, %s", name.c_str()) - Additional
.on_change()method for logging changes in values - Chrono syntax for throttling:
logger.warn_throttle(1s, "Warning: {}", value) - Backwards compatible with the macros, so easy to start using in existing projects without a full rewrite of the current log statements
Examples
Once-only logging
logger.info_once("This message will only appear once, no matter how many times called");
Throttled logging
using std::chrono_literals::operator""s;
logger.warn_throttle(1s, "This warning appears at most once per second: {}", value);
Change-based logging
// Log only when the value changes
logger.info_on_change(sensor_value, "Sensor reading changed to: {}", sensor_value);
// Log only when change exceeds threshold
logger.error_on_change(temperature, 5.0, "Temperature changed significantly: {:.1f}°C", temperature);
Quick Start
Include in the package.xml
<depend>ros2_fmt_logger</depend>
Configure c++20 and find_package
find_package(ros2_fmt_logger REQUIRED)
target_link_libraries(your_target ros2_fmt_logger::ros2_fmt_logger)
Include the header
#include <ros2_fmt_logger/logger.hpp>
Create a logger instance
// From an rclcpp::Logger
auto logger = ros2_fmt_logger::Logger(node->get_logger());
// With custom clock for throttling features
auto logger = ros2_fmt_logger::Logger(node->get_logger(), node->get_clock());
3. Use modern logging syntax
// Instead of: RCLCPP_INFO(logger, "Processing item %d with value %.2f", id, value);
logger.info("Processing item {} with value {:.2f}", id, value);
// Instead of: RCLCPP_ERROR(logger, "Failed to connect to %s:%d", host.c_str(), port);
logger.error("Failed to connect to {}:{}", host, port);
Format String Syntax
Uses the powerful fmt library format syntax:
```cpp // Basic formatting logger.info(“Hello, {}!”, name);
// Positional arguments logger.info(“Processing {1} of {0} items”, total, current);
File truncated at 100 lines see the full file
CONTRIBUTING
No version for distro kinetic showing humble. Known supported distros are highlighted in the buttons above.
Repository Summary
| Checkout URI | https://github.com/nobleo/ros2_fmt_logger.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-08-24 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| ros2_fmt_logger | 1.1.0 |
README
ros2_fmt_logger
A modern, ROS 2 logging library that provides fmt-style formatting as a replacement for RCLCPP logging macros.
Features
- Function calls instead of macros:
logger.info("Hello, {}!", name)instead ofRCLCPP_INFO(logger, "Hello, %s", name.c_str()) - Additional
.on_change()method for logging changes in values - Chrono syntax for throttling:
logger.warn_throttle(1s, "Warning: {}", value) - Backwards compatible with the macros, so easy to start using in existing projects without a full rewrite of the current log statements
Examples
Once-only logging
logger.info_once("This message will only appear once, no matter how many times called");
Throttled logging
using std::chrono_literals::operator""s;
logger.warn_throttle(1s, "This warning appears at most once per second: {}", value);
Change-based logging
// Log only when the value changes
logger.info_on_change(sensor_value, "Sensor reading changed to: {}", sensor_value);
// Log only when change exceeds threshold
logger.error_on_change(temperature, 5.0, "Temperature changed significantly: {:.1f}°C", temperature);
Quick Start
Include in the package.xml
<depend>ros2_fmt_logger</depend>
Configure c++20 and find_package
find_package(ros2_fmt_logger REQUIRED)
target_link_libraries(your_target ros2_fmt_logger::ros2_fmt_logger)
Include the header
#include <ros2_fmt_logger/logger.hpp>
Create a logger instance
// From an rclcpp::Logger
auto logger = ros2_fmt_logger::Logger(node->get_logger());
// With custom clock for throttling features
auto logger = ros2_fmt_logger::Logger(node->get_logger(), node->get_clock());
3. Use modern logging syntax
// Instead of: RCLCPP_INFO(logger, "Processing item %d with value %.2f", id, value);
logger.info("Processing item {} with value {:.2f}", id, value);
// Instead of: RCLCPP_ERROR(logger, "Failed to connect to %s:%d", host.c_str(), port);
logger.error("Failed to connect to {}:{}", host, port);
Format String Syntax
Uses the powerful fmt library format syntax:
```cpp // Basic formatting logger.info(“Hello, {}!”, name);
// Positional arguments logger.info(“Processing {1} of {0} items”, total, current);
File truncated at 100 lines see the full file
CONTRIBUTING
No version for distro melodic showing humble. Known supported distros are highlighted in the buttons above.
Repository Summary
| Checkout URI | https://github.com/nobleo/ros2_fmt_logger.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-08-24 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| ros2_fmt_logger | 1.1.0 |
README
ros2_fmt_logger
A modern, ROS 2 logging library that provides fmt-style formatting as a replacement for RCLCPP logging macros.
Features
- Function calls instead of macros:
logger.info("Hello, {}!", name)instead ofRCLCPP_INFO(logger, "Hello, %s", name.c_str()) - Additional
.on_change()method for logging changes in values - Chrono syntax for throttling:
logger.warn_throttle(1s, "Warning: {}", value) - Backwards compatible with the macros, so easy to start using in existing projects without a full rewrite of the current log statements
Examples
Once-only logging
logger.info_once("This message will only appear once, no matter how many times called");
Throttled logging
using std::chrono_literals::operator""s;
logger.warn_throttle(1s, "This warning appears at most once per second: {}", value);
Change-based logging
// Log only when the value changes
logger.info_on_change(sensor_value, "Sensor reading changed to: {}", sensor_value);
// Log only when change exceeds threshold
logger.error_on_change(temperature, 5.0, "Temperature changed significantly: {:.1f}°C", temperature);
Quick Start
Include in the package.xml
<depend>ros2_fmt_logger</depend>
Configure c++20 and find_package
find_package(ros2_fmt_logger REQUIRED)
target_link_libraries(your_target ros2_fmt_logger::ros2_fmt_logger)
Include the header
#include <ros2_fmt_logger/logger.hpp>
Create a logger instance
// From an rclcpp::Logger
auto logger = ros2_fmt_logger::Logger(node->get_logger());
// With custom clock for throttling features
auto logger = ros2_fmt_logger::Logger(node->get_logger(), node->get_clock());
3. Use modern logging syntax
// Instead of: RCLCPP_INFO(logger, "Processing item %d with value %.2f", id, value);
logger.info("Processing item {} with value {:.2f}", id, value);
// Instead of: RCLCPP_ERROR(logger, "Failed to connect to %s:%d", host.c_str(), port);
logger.error("Failed to connect to {}:{}", host, port);
Format String Syntax
Uses the powerful fmt library format syntax:
```cpp // Basic formatting logger.info(“Hello, {}!”, name);
// Positional arguments logger.info(“Processing {1} of {0} items”, total, current);
File truncated at 100 lines see the full file
CONTRIBUTING
No version for distro noetic showing humble. Known supported distros are highlighted in the buttons above.
Repository Summary
| Checkout URI | https://github.com/nobleo/ros2_fmt_logger.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-08-24 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| ros2_fmt_logger | 1.1.0 |
README
ros2_fmt_logger
A modern, ROS 2 logging library that provides fmt-style formatting as a replacement for RCLCPP logging macros.
Features
- Function calls instead of macros:
logger.info("Hello, {}!", name)instead ofRCLCPP_INFO(logger, "Hello, %s", name.c_str()) - Additional
.on_change()method for logging changes in values - Chrono syntax for throttling:
logger.warn_throttle(1s, "Warning: {}", value) - Backwards compatible with the macros, so easy to start using in existing projects without a full rewrite of the current log statements
Examples
Once-only logging
logger.info_once("This message will only appear once, no matter how many times called");
Throttled logging
using std::chrono_literals::operator""s;
logger.warn_throttle(1s, "This warning appears at most once per second: {}", value);
Change-based logging
// Log only when the value changes
logger.info_on_change(sensor_value, "Sensor reading changed to: {}", sensor_value);
// Log only when change exceeds threshold
logger.error_on_change(temperature, 5.0, "Temperature changed significantly: {:.1f}°C", temperature);
Quick Start
Include in the package.xml
<depend>ros2_fmt_logger</depend>
Configure c++20 and find_package
find_package(ros2_fmt_logger REQUIRED)
target_link_libraries(your_target ros2_fmt_logger::ros2_fmt_logger)
Include the header
#include <ros2_fmt_logger/logger.hpp>
Create a logger instance
// From an rclcpp::Logger
auto logger = ros2_fmt_logger::Logger(node->get_logger());
// With custom clock for throttling features
auto logger = ros2_fmt_logger::Logger(node->get_logger(), node->get_clock());
3. Use modern logging syntax
// Instead of: RCLCPP_INFO(logger, "Processing item %d with value %.2f", id, value);
logger.info("Processing item {} with value {:.2f}", id, value);
// Instead of: RCLCPP_ERROR(logger, "Failed to connect to %s:%d", host.c_str(), port);
logger.error("Failed to connect to {}:{}", host, port);
Format String Syntax
Uses the powerful fmt library format syntax:
```cpp // Basic formatting logger.info(“Hello, {}!”, name);
// Positional arguments logger.info(“Processing {1} of {0} items”, total, current);
File truncated at 100 lines see the full file