Program Listing for File logging.hpp

↰ Return to documentation for file (include/rclcpp/logging.hpp)

// Copyright 2017 Open Source Robotics Foundation, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#ifndef RCLCPP__LOGGING_HPP_
#define RCLCPP__LOGGING_HPP_

#include <sstream>
#include <type_traits>

#include "rclcpp/logger.hpp"
#include "rcutils/logging_macros.h"

// These are used for compiling out logging macros lower than a minimum severity.
#define RCLCPP_LOG_MIN_SEVERITY_DEBUG 0
#define RCLCPP_LOG_MIN_SEVERITY_INFO 1
#define RCLCPP_LOG_MIN_SEVERITY_WARN 2
#define RCLCPP_LOG_MIN_SEVERITY_ERROR 3
#define RCLCPP_LOG_MIN_SEVERITY_FATAL 4
#define RCLCPP_LOG_MIN_SEVERITY_NONE 5

#define RCLCPP_STATIC_ASSERT_LOGGER(logger) \
  do { \
    static_assert( \
      ::std::is_convertible_v<decltype(logger), ::rclcpp::Logger>, \
      "First argument to logging macros must be an rclcpp::Logger"); \
  } while (0)

#define RCLCPP_LOG(severity, logger, ...) \
  do { \
    RCLCPP_STATIC_ASSERT_LOGGER(logger); \
    RCUTILS_LOG_NAMED(severity, (logger).get_name(), __VA_ARGS__); \
  } while (0)

#define RCLCPP_LOG_ONCE(severity, logger, ...) \
  do { \
    RCLCPP_STATIC_ASSERT_LOGGER(logger); \
    RCUTILS_LOG_ONCE_NAMED(severity, (logger).get_name(), __VA_ARGS__); \
  } while (0)

#define RCLCPP_LOG_EXPRESSION(severity, logger, expression, ...) \
  do { \
    RCLCPP_STATIC_ASSERT_LOGGER(logger); \
    RCUTILS_LOG_EXPRESSION_NAMED(severity, expression, (logger).get_name(), __VA_ARGS__); \
  } while (0)

#define RCLCPP_LOG_FUNCTION(severity, logger, function, ...) \
  do { \
    RCLCPP_STATIC_ASSERT_LOGGER(logger); \
    RCUTILS_LOG_FUNCTION_NAMED(severity, function, (logger).get_name(), __VA_ARGS__); \
  } while (0)

#define RCLCPP_LOG_SKIPFIRST(severity, logger, ...) \
  do { \
    RCLCPP_STATIC_ASSERT_LOGGER(logger); \
    RCUTILS_LOG_SKIPFIRST_NAMED(severity, (logger).get_name(), __VA_ARGS__); \
  } while (0)

#define RCLCPP_LOG_TIME_POINT_FUNC(clock) \
  [&c = clock](rcutils_time_point_value_t * time_point)->rcutils_ret_t { \
    try { \
      *time_point = c.now().nanoseconds(); \
    } catch (...) { \
      RCUTILS_SAFE_FWRITE_TO_STDERR( \
      "[rclcpp|logging.hpp] RCLCPP_DEBUG_THROTTLE could not get current time stamp\n"); \
      return RCUTILS_RET_ERROR; \
    } \
    return RCUTILS_RET_OK; \
  }

#define RCLCPP_LOG_THROTTLE(severity, logger, clock, duration, ...) \
  do { \
    RCLCPP_STATIC_ASSERT_LOGGER(logger); \
    RCUTILS_LOG_THROTTLE_NAMED( \
      severity, \
      RCLCPP_LOG_TIME_POINT_FUNC(clock), \
      duration, \
      (logger).get_name(), \
      __VA_ARGS__); \
  } while (0)

#define RCLCPP_LOG_SKIPFIRST_THROTTLE(severity, logger, clock, duration, ...) \
  do { \
    RCLCPP_STATIC_ASSERT_LOGGER(logger); \
    RCUTILS_LOG_SKIPFIRST_THROTTLE_NAMED( \
      severity, \
      RCLCPP_LOG_TIME_POINT_FUNC(clock), \
      duration, \
      (logger).get_name(), \
      __VA_ARGS__); \
  } while (0)

#define RCLCPP_LOG_STREAM(severity, logger, stream_arg) \
  do { \
    RCLCPP_STATIC_ASSERT_LOGGER(logger); \
    std::stringstream rclcpp_stream_ss_; \
    rclcpp_stream_ss_ << stream_arg; \
    RCUTILS_LOG_NAMED(severity, (logger).get_name(), "%s", rclcpp_stream_ss_.str().c_str()); \
  } while (0)

#define RCLCPP_LOG_STREAM_ONCE(severity, logger, stream_arg) \
  do { \
    RCLCPP_STATIC_ASSERT_LOGGER(logger); \
    std::stringstream rclcpp_stream_ss_; \
    rclcpp_stream_ss_ << stream_arg; \
    RCUTILS_LOG_ONCE_NAMED(severity, (logger).get_name(), "%s", rclcpp_stream_ss_.str().c_str()); \
  } while (0)

#define RCLCPP_LOG_STREAM_EXPRESSION(severity, logger, expression, stream_arg) \
  do { \
    RCLCPP_STATIC_ASSERT_LOGGER(logger); \
    std::stringstream rclcpp_stream_ss_; \
    rclcpp_stream_ss_ << stream_arg; \
    RCUTILS_LOG_EXPRESSION_NAMED( \
      severity, \
      expression, \
      (logger).get_name(), \
      "%s", rclcpp_stream_ss_.str().c_str()); \
  } while (0)

#define RCLCPP_LOG_STREAM_FUNCTION(severity, logger, function, stream_arg) \
  do { \
    RCLCPP_STATIC_ASSERT_LOGGER(logger); \
    std::stringstream rclcpp_stream_ss_; \
    rclcpp_stream_ss_ << stream_arg; \
    RCUTILS_LOG_FUNCTION_NAMED( \
      severity, \
      function, \
      (logger).get_name(), \
      "%s", rclcpp_stream_ss_.str().c_str()); \
  } while (0)

#define RCLCPP_LOG_STREAM_SKIPFIRST(severity, logger, stream_arg) \
  do { \
    RCLCPP_STATIC_ASSERT_LOGGER(logger); \
    std::stringstream rclcpp_stream_ss_; \
    rclcpp_stream_ss_ << stream_arg; \
    RCUTILS_LOG_SKIPFIRST_NAMED( \
      severity, \
      (logger).get_name(), \
      "%s", rclcpp_stream_ss_.str().c_str()); \
  } while (0)

#define RCLCPP_LOG_STREAM_THROTTLE(severity, logger, clock, duration, stream_arg) \
  do { \
    RCLCPP_STATIC_ASSERT_LOGGER(logger); \
    std::stringstream rclcpp_stream_ss_; \
    rclcpp_stream_ss_ << stream_arg; \
    RCUTILS_LOG_THROTTLE_NAMED( \
      severity, \
      RCLCPP_LOG_TIME_POINT_FUNC(clock), \
      duration, \
      (logger).get_name(), \
      "%s", rclcpp_stream_ss_.str().c_str()); \
  } while (0)

#define RCLCPP_LOG_STREAM_SKIPFIRST_THROTTLE(severity, logger, clock, duration, stream_arg) \
  do { \
    RCLCPP_STATIC_ASSERT_LOGGER(logger); \
    std::stringstream rclcpp_stream_ss_; \
    rclcpp_stream_ss_ << stream_arg; \
    RCUTILS_LOG_SKIPFIRST_THROTTLE_NAMED( \
      severity, \
      RCLCPP_LOG_TIME_POINT_FUNC(clock), \
      duration, \
      (logger).get_name(), \
      "%s", rclcpp_stream_ss_.str().c_str()); \
  } while (0)

#ifndef RCLCPP_LOG_MIN_SEVERITY
#define RCLCPP_LOG_MIN_SEVERITY RCLCPP_LOG_MIN_SEVERITY_DEBUG
#endif

#if (RCLCPP_LOG_MIN_SEVERITY > RCLCPP_LOG_MIN_SEVERITY_DEBUG)
// empty logging macros for severity DEBUG when being disabled at compile time
#define RCLCPP_DEBUG(...)
#define RCLCPP_DEBUG_ONCE(...)
#define RCLCPP_DEBUG_EXPRESSION(...)
#define RCLCPP_DEBUG_FUNCTION(...)
#define RCLCPP_DEBUG_SKIPFIRST(...)
#define RCLCPP_DEBUG_THROTTLE(...)
#define RCLCPP_DEBUG_SKIPFIRST_THROTTLE(...)
#define RCLCPP_DEBUG_STREAM(...)
#define RCLCPP_DEBUG_STREAM_ONCE(...)
#define RCLCPP_DEBUG_STREAM_EXPRESSION(...)
#define RCLCPP_DEBUG_STREAM_FUNCTION(...)
#define RCLCPP_DEBUG_STREAM_SKIPFIRST(...)
#define RCLCPP_DEBUG_STREAM_THROTTLE(...)
#define RCLCPP_DEBUG_STREAM_SKIPFIRST_THROTTLE(...)

#else
#define RCLCPP_DEBUG(logger, ...) RCLCPP_LOG(RCUTILS_LOG_SEVERITY_DEBUG, logger, __VA_ARGS__)

#define RCLCPP_DEBUG_ONCE(logger, ...) \
  RCLCPP_LOG_ONCE(RCUTILS_LOG_SEVERITY_DEBUG, logger, __VA_ARGS__)

#define RCLCPP_DEBUG_EXPRESSION(logger, expression, ...) \
  RCLCPP_LOG_EXPRESSION(RCUTILS_LOG_SEVERITY_DEBUG, logger, expression, __VA_ARGS__)

#define RCLCPP_DEBUG_FUNCTION(logger, function, ...) \
  RCLCPP_LOG_FUNCTION(RCUTILS_LOG_SEVERITY_DEBUG, logger, function, __VA_ARGS__)

#define RCLCPP_DEBUG_SKIPFIRST(logger, ...) \
  RCLCPP_LOG_SKIPFIRST(RCUTILS_LOG_SEVERITY_DEBUG, logger, __VA_ARGS__)

#define RCLCPP_DEBUG_THROTTLE(logger, clock, duration, ...) \
  RCLCPP_LOG_THROTTLE(RCUTILS_LOG_SEVERITY_DEBUG, logger, clock, duration, __VA_ARGS__)

#define RCLCPP_DEBUG_SKIPFIRST_THROTTLE(logger, clock, duration, ...) \
  RCLCPP_LOG_SKIPFIRST_THROTTLE(RCUTILS_LOG_SEVERITY_DEBUG, logger, clock, duration, __VA_ARGS__)

#define RCLCPP_DEBUG_STREAM(logger, stream_arg) \
  RCLCPP_LOG_STREAM(RCUTILS_LOG_SEVERITY_DEBUG, logger, stream_arg)

#define RCLCPP_DEBUG_STREAM_ONCE(logger, stream_arg) \
  RCLCPP_LOG_STREAM_ONCE(RCUTILS_LOG_SEVERITY_DEBUG, logger, stream_arg)

#define RCLCPP_DEBUG_STREAM_EXPRESSION(logger, expression, stream_arg) \
  RCLCPP_LOG_STREAM_EXPRESSION(RCUTILS_LOG_SEVERITY_DEBUG, logger, expression, stream_arg)

#define RCLCPP_DEBUG_STREAM_FUNCTION(logger, function, stream_arg) \
  RCLCPP_LOG_STREAM_FUNCTION(RCUTILS_LOG_SEVERITY_DEBUG, logger, function, stream_args)

#define RCLCPP_DEBUG_STREAM_SKIPFIRST(logger, stream_arg) \
  RCLCPP_LOG_STREAM_SKIPFIRST(RCUTILS_LOG_SEVERITY_DEBUG, logger, stream_arg)

#define RCLCPP_DEBUG_STREAM_THROTTLE(logger, clock, duration, stream_arg) \
  RCLCPP_LOG_STREAM_THROTTLE(RCUTILS_LOG_SEVERITY_DEBUG, logger, clock, duration, stream_arg)

#define RCLCPP_DEBUG_STREAM_SKIPFIRST_THROTTLE(logger, clock, duration, stream_arg) \
  RCLCPP_LOG_STREAM_SKIPFIRST_THROTTLE(RCUTILS_LOG_SEVERITY_DEBUG, logger, clock, duration, \
    stream_arg)

#endif

#if (RCLCPP_LOG_MIN_SEVERITY > RCLCPP_LOG_MIN_SEVERITY_INFO)
// empty logging macros for severity INFO when being disabled at compile time
#define RCLCPP_INFO(...)
#define RCLCPP_INFO_ONCE(...)
#define RCLCPP_INFO_EXPRESSION(...)
#define RCLCPP_INFO_FUNCTION(...)
#define RCLCPP_INFO_SKIPFIRST(...)
#define RCLCPP_INFO_THROTTLE(...)
#define RCLCPP_INFO_SKIPFIRST_THROTTLE(...)
#define RCLCPP_INFO_STREAM(...)
#define RCLCPP_INFO_STREAM_ONCE(...)
#define RCLCPP_INFO_STREAM_EXPRESSION(...)
#define RCLCPP_INFO_STREAM_FUNCTION(...)
#define RCLCPP_INFO_STREAM_SKIPFIRST(...)
#define RCLCPP_INFO_STREAM_THROTTLE(...)
#define RCLCPP_INFO_STREAM_SKIPFIRST_THROTTLE(...)

#else
#define RCLCPP_INFO(logger, ...) RCLCPP_LOG(RCUTILS_LOG_SEVERITY_INFO, logger, __VA_ARGS__)

#define RCLCPP_INFO_ONCE(logger, ...) \
  RCLCPP_LOG_ONCE(RCUTILS_LOG_SEVERITY_INFO, logger, __VA_ARGS__)

#define RCLCPP_INFO_EXPRESSION(logger, expression, ...) \
  RCLCPP_LOG_EXPRESSION(RCUTILS_LOG_SEVERITY_INFO, logger, expression, __VA_ARGS__)

#define RCLCPP_INFO_FUNCTION(logger, function, ...) \
  RCLCPP_LOG_FUNCTION(RCUTILS_LOG_SEVERITY_INFO, logger, function, __VA_ARGS__)

#define RCLCPP_INFO_SKIPFIRST(logger, ...) \
  RCLCPP_LOG_SKIPFIRST(RCUTILS_LOG_SEVERITY_INFO, logger, __VA_ARGS__)

#define RCLCPP_INFO_THROTTLE(logger, clock, duration, ...) \
  RCLCPP_LOG_THROTTLE(RCUTILS_LOG_SEVERITY_INFO, logger, clock, duration, __VA_ARGS__)

#define RCLCPP_INFO_SKIPFIRST_THROTTLE(logger, clock, duration, ...) \
  RCLCPP_LOG_SKIPFIRST_THROTTLE(RCUTILS_LOG_SEVERITY_INFO, logger, clock, duration, __VA_ARGS__)

#define RCLCPP_INFO_STREAM(logger, stream_arg) \
  RCLCPP_LOG_STREAM(RCUTILS_LOG_SEVERITY_INFO, logger, stream_arg)

#define RCLCPP_INFO_STREAM_ONCE(logger, stream_arg) \
  RCLCPP_LOG_STREAM_ONCE(RCUTILS_LOG_SEVERITY_INFO, logger, stream_arg)

#define RCLCPP_INFO_STREAM_EXPRESSION(logger, expression, stream_arg) \
  RCLCPP_LOG_STREAM_EXPRESSION(RCUTILS_LOG_SEVERITY_INFO, logger, expression, stream_arg)

#define RCLCPP_INFO_STREAM_FUNCTION(logger, function, stream_arg) \
  RCLCPP_LOG_STREAM_FUNCTION(RCUTILS_LOG_SEVERITY_INFO, logger, function, stream_args)

#define RCLCPP_INFO_STREAM_SKIPFIRST(logger, stream_arg) \
  RCLCPP_LOG_STREAM_SKIPFIRST(RCUTILS_LOG_SEVERITY_INFO, logger, stream_arg)

#define RCLCPP_INFO_STREAM_THROTTLE(logger, clock, duration, stream_arg) \
  RCLCPP_LOG_STREAM_THROTTLE(RCUTILS_LOG_SEVERITY_INFO, logger, clock, duration, stream_arg)

#define RCLCPP_INFO_STREAM_SKIPFIRST_THROTTLE(logger, clock, duration, stream_arg) \
  RCLCPP_LOG_STREAM_SKIPFIRST_THROTTLE(RCUTILS_LOG_SEVERITY_INFO, logger, clock, duration, \
    stream_arg)

#endif

#if (RCLCPP_LOG_MIN_SEVERITY > RCLCPP_LOG_MIN_SEVERITY_WARN)
// empty logging macros for severity WARN when being disabled at compile time
#define RCLCPP_WARN(...)
#define RCLCPP_WARN_ONCE(...)
#define RCLCPP_WARN_EXPRESSION(...)
#define RCLCPP_WARN_FUNCTION(...)
#define RCLCPP_WARN_SKIPFIRST(...)
#define RCLCPP_WARN_THROTTLE(...)
#define RCLCPP_WARN_SKIPFIRST_THROTTLE(...)
#define RCLCPP_WARN_STREAM(...)
#define RCLCPP_WARN_STREAM_ONCE(...)
#define RCLCPP_WARN_STREAM_EXPRESSION(...)
#define RCLCPP_WARN_STREAM_FUNCTION(...)
#define RCLCPP_WARN_STREAM_SKIPFIRST(...)
#define RCLCPP_WARN_STREAM_THROTTLE(...)
#define RCLCPP_WARN_STREAM_SKIPFIRST_THROTTLE(...)

#else
#define RCLCPP_WARN(logger, ...) RCLCPP_LOG(RCUTILS_LOG_SEVERITY_WARN, logger, __VA_ARGS__)

#define RCLCPP_WARN_ONCE(logger, ...) \
  RCLCPP_LOG_ONCE(RCUTILS_LOG_SEVERITY_WARN, logger, __VA_ARGS__)

#define RCLCPP_WARN_EXPRESSION(logger, expression, ...) \
  RCLCPP_LOG_EXPRESSION(RCUTILS_LOG_SEVERITY_WARN, logger, expression, __VA_ARGS__)

#define RCLCPP_WARN_FUNCTION(logger, function, ...) \
  RCLCPP_LOG_FUNCTION(RCUTILS_LOG_SEVERITY_WARN, logger, function, __VA_ARGS__)

#define RCLCPP_WARN_SKIPFIRST(logger, ...) \
  RCLCPP_LOG_SKIPFIRST(RCUTILS_LOG_SEVERITY_WARN, logger, __VA_ARGS__)

#define RCLCPP_WARN_THROTTLE(logger, clock, duration, ...) \
  RCLCPP_LOG_THROTTLE(RCUTILS_LOG_SEVERITY_WARN, logger, clock, duration, __VA_ARGS__)

#define RCLCPP_WARN_SKIPFIRST_THROTTLE(logger, clock, duration, ...) \
  RCLCPP_LOG_SKIPFIRST_THROTTLE(RCUTILS_LOG_SEVERITY_WARN, logger, clock, duration, __VA_ARGS__)

#define RCLCPP_WARN_STREAM(logger, stream_arg) \
  RCLCPP_LOG_STREAM(RCUTILS_LOG_SEVERITY_WARN, logger, stream_arg)

#define RCLCPP_WARN_STREAM_ONCE(logger, stream_arg) \
  RCLCPP_LOG_STREAM_ONCE(RCUTILS_LOG_SEVERITY_WARN, logger, stream_arg)

#define RCLCPP_WARN_STREAM_EXPRESSION(logger, expression, stream_arg) \
  RCLCPP_LOG_STREAM_EXPRESSION(RCUTILS_LOG_SEVERITY_WARN, logger, expression, stream_arg)

#define RCLCPP_WARN_STREAM_FUNCTION(logger, function, stream_arg) \
  RCLCPP_LOG_STREAM_FUNCTION(RCUTILS_LOG_SEVERITY_WARN, logger, function, stream_args)

#define RCLCPP_WARN_STREAM_SKIPFIRST(logger, stream_arg) \
  RCLCPP_LOG_STREAM_SKIPFIRST(RCUTILS_LOG_SEVERITY_WARN, logger, stream_arg)

#define RCLCPP_WARN_STREAM_THROTTLE(logger, clock, duration, stream_arg) \
  RCLCPP_LOG_STREAM_THROTTLE(RCUTILS_LOG_SEVERITY_WARN, logger, clock, duration, stream_arg)

#define RCLCPP_WARN_STREAM_SKIPFIRST_THROTTLE(logger, clock, duration, stream_arg) \
  RCLCPP_LOG_STREAM_SKIPFIRST_THROTTLE(RCUTILS_LOG_SEVERITY_WARN, logger, clock, duration, \
    stream_arg)

#endif

#if (RCLCPP_LOG_MIN_SEVERITY > RCLCPP_LOG_MIN_SEVERITY_ERROR)
// empty logging macros for severity ERROR when being disabled at compile time
#define RCLCPP_ERROR(...)
#define RCLCPP_ERROR_ONCE(...)
#define RCLCPP_ERROR_EXPRESSION(...)
#define RCLCPP_ERROR_FUNCTION(...)
#define RCLCPP_ERROR_SKIPFIRST(...)
#define RCLCPP_ERROR_THROTTLE(...)
#define RCLCPP_ERROR_SKIPFIRST_THROTTLE(...)
#define RCLCPP_ERROR_STREAM(...)
#define RCLCPP_ERROR_STREAM_ONCE(...)
#define RCLCPP_ERROR_STREAM_EXPRESSION(...)
#define RCLCPP_ERROR_STREAM_FUNCTION(...)
#define RCLCPP_ERROR_STREAM_SKIPFIRST(...)
#define RCLCPP_ERROR_STREAM_THROTTLE(...)
#define RCLCPP_ERROR_STREAM_SKIPFIRST_THROTTLE(...)

#else
#define RCLCPP_ERROR(logger, ...) RCLCPP_LOG(RCUTILS_LOG_SEVERITY_ERROR, logger, __VA_ARGS__)

#define RCLCPP_ERROR_ONCE(logger, ...) \
  RCLCPP_LOG_ONCE(RCUTILS_LOG_SEVERITY_ERROR, logger, __VA_ARGS__)

#define RCLCPP_ERROR_EXPRESSION(logger, expression, ...) \
  RCLCPP_LOG_EXPRESSION(RCUTILS_LOG_SEVERITY_ERROR, logger, expression, __VA_ARGS__)

#define RCLCPP_ERROR_FUNCTION(logger, function, ...) \
  RCLCPP_LOG_FUNCTION(RCUTILS_LOG_SEVERITY_ERROR, logger, function, __VA_ARGS__)

#define RCLCPP_ERROR_SKIPFIRST(logger, ...) \
  RCLCPP_LOG_SKIPFIRST(RCUTILS_LOG_SEVERITY_ERROR, logger, __VA_ARGS__)

#define RCLCPP_ERROR_THROTTLE(logger, clock, duration, ...) \
  RCLCPP_LOG_THROTTLE(RCUTILS_LOG_SEVERITY_ERROR, logger, clock, duration, __VA_ARGS__)

#define RCLCPP_ERROR_SKIPFIRST_THROTTLE(logger, clock, duration, ...) \
  RCLCPP_LOG_SKIPFIRST_THROTTLE(RCUTILS_LOG_SEVERITY_ERROR, logger, clock, duration, __VA_ARGS__)

#define RCLCPP_ERROR_STREAM(logger, stream_arg) \
  RCLCPP_LOG_STREAM(RCUTILS_LOG_SEVERITY_ERROR, logger, stream_arg)

#define RCLCPP_ERROR_STREAM_ONCE(logger, stream_arg) \
  RCLCPP_LOG_STREAM_ONCE(RCUTILS_LOG_SEVERITY_ERROR, logger, stream_arg)

#define RCLCPP_ERROR_STREAM_EXPRESSION(logger, expression, stream_arg) \
  RCLCPP_LOG_STREAM_EXPRESSION(RCUTILS_LOG_SEVERITY_ERROR, logger, expression, stream_arg)

#define RCLCPP_ERROR_STREAM_FUNCTION(logger, function, stream_arg) \
  RCLCPP_LOG_STREAM_FUNCTION(RCUTILS_LOG_SEVERITY_ERROR, logger, function, stream_args)

#define RCLCPP_ERROR_STREAM_SKIPFIRST(logger, stream_arg) \
  RCLCPP_LOG_STREAM_SKIPFIRST(RCUTILS_LOG_SEVERITY_ERROR, logger, stream_arg)

#define RCLCPP_ERROR_STREAM_THROTTLE(logger, clock, duration, stream_arg) \
  RCLCPP_LOG_STREAM_THROTTLE(RCUTILS_LOG_SEVERITY_ERROR, logger, clock, duration, stream_arg)

#define RCLCPP_ERROR_STREAM_SKIPFIRST_THROTTLE(logger, clock, duration, stream_arg) \
  RCLCPP_LOG_STREAM_SKIPFIRST_THROTTLE(RCUTILS_LOG_SEVERITY_ERROR, logger, clock, duration, \
    stream_arg)

#endif

#if (RCLCPP_LOG_MIN_SEVERITY > RCLCPP_LOG_MIN_SEVERITY_FATAL)
// empty logging macros for severity FATAL when being disabled at compile time
#define RCLCPP_FATAL(...)
#define RCLCPP_FATAL_ONCE(...)
#define RCLCPP_FATAL_EXPRESSION(...)
#define RCLCPP_FATAL_FUNCTION(...)
#define RCLCPP_FATAL_SKIPFIRST(...)
#define RCLCPP_FATAL_THROTTLE(...)
#define RCLCPP_FATAL_SKIPFIRST_THROTTLE(...)
#define RCLCPP_FATAL_STREAM(...)
#define RCLCPP_FATAL_STREAM_ONCE(...)
#define RCLCPP_FATAL_STREAM_EXPRESSION(...)
#define RCLCPP_FATAL_STREAM_FUNCTION(...)
#define RCLCPP_FATAL_STREAM_SKIPFIRST(...)
#define RCLCPP_FATAL_STREAM_THROTTLE(...)
#define RCLCPP_FATAL_STREAM_SKIPFIRST_THROTTLE(...)

#else
#define RCLCPP_FATAL(logger, ...) RCLCPP_LOG(RCUTILS_LOG_SEVERITY_FATAL, logger, __VA_ARGS__)

#define RCLCPP_FATAL_ONCE(logger, ...) \
  RCLCPP_LOG_ONCE(RCUTILS_LOG_SEVERITY_FATAL, logger, __VA_ARGS__)

#define RCLCPP_FATAL_EXPRESSION(logger, expression, ...) \
  RCLCPP_LOG_EXPRESSION(RCUTILS_LOG_SEVERITY_FATAL, logger, expression, __VA_ARGS__)

#define RCLCPP_FATAL_FUNCTION(logger, function, ...) \
  RCLCPP_LOG_FUNCTION(RCUTILS_LOG_SEVERITY_FATAL, logger, function, __VA_ARGS__)

#define RCLCPP_FATAL_SKIPFIRST(logger, ...) \
  RCLCPP_LOG_SKIPFIRST(RCUTILS_LOG_SEVERITY_FATAL, logger, __VA_ARGS__)

#define RCLCPP_FATAL_THROTTLE(logger, clock, duration, ...) \
  RCLCPP_LOG_THROTTLE(RCUTILS_LOG_SEVERITY_FATAL, logger, clock, duration, __VA_ARGS__)

#define RCLCPP_FATAL_SKIPFIRST_THROTTLE(logger, clock, duration, ...) \
  RCLCPP_LOG_SKIPFIRST_THROTTLE(RCUTILS_LOG_SEVERITY_FATAL, logger, clock, duration, __VA_ARGS__)

#define RCLCPP_FATAL_STREAM(logger, stream_arg) \
  RCLCPP_LOG_STREAM(RCUTILS_LOG_SEVERITY_FATAL, logger, stream_arg)

#define RCLCPP_FATAL_STREAM_ONCE(logger, stream_arg) \
  RCLCPP_LOG_STREAM_ONCE(RCUTILS_LOG_SEVERITY_FATAL, logger, stream_arg)

#define RCLCPP_FATAL_STREAM_EXPRESSION(logger, expression, stream_arg) \
  RCLCPP_LOG_STREAM_EXPRESSION(RCUTILS_LOG_SEVERITY_FATAL, logger, expression, stream_arg)

#define RCLCPP_FATAL_STREAM_FUNCTION(logger, function, stream_arg) \
  RCLCPP_LOG_STREAM_FUNCTION(RCUTILS_LOG_SEVERITY_FATAL, logger, function, stream_args)

#define RCLCPP_FATAL_STREAM_SKIPFIRST(logger, stream_arg) \
  RCLCPP_LOG_STREAM_SKIPFIRST(RCUTILS_LOG_SEVERITY_FATAL, logger, stream_arg)

#define RCLCPP_FATAL_STREAM_THROTTLE(logger, clock, duration, stream_arg) \
  RCLCPP_LOG_STREAM_THROTTLE(RCUTILS_LOG_SEVERITY_FATAL, logger, clock, duration, stream_arg)

#define RCLCPP_FATAL_STREAM_SKIPFIRST_THROTTLE(logger, clock, duration, stream_arg) \
  RCLCPP_LOG_STREAM_SKIPFIRST_THROTTLE(RCUTILS_LOG_SEVERITY_FATAL, logger, clock, duration, \
    stream_arg)

#endif

#endif  // RCLCPP__LOGGING_HPP_