fix: node filter improvement

CARET_trace/include/caret_trace/data_container.hpp

@@ -36,7 +36,7 @@
   /// @return True if record has finished, false otherwise.
   virtual bool record(uint64_t loop_count = 1) = 0;
 
-  /// @brief transitionto recording state.
+  /// @brief transitiont recording state.
   virtual void start_recording() = 0;
 
   /// @brief Reset recording state.
@@ -48,11 +48,12 @@
 {
 public:
   /// @brief  for add_callback_group trace points.
-  using AddCallbackGroup = ContainerTraits<const void *, const void *, const char *, int64_t>;
+  using AddCallbackGroup =
+    ContainerTraits<const void *, const void *, const char *, const void *, int64_t>;
 
   /// @brief ContainerTraits for add_callback_group_static_executor trace points.
   using AddCallbackGroupStaticExecutor =
-    ContainerTraits<const void *, const void *, const char *, int64_t>;
+    ContainerTraits<const void *, const void *, const char *, const void *, int64_t>;
 
   /// @brief ContainerTraits for callback_group_add_client trace points.
   using CallbackGroupAddClient = ContainerTraits<const void *, const void *, int64_t>;

CARET_trace/include/caret_trace/tracing_controller.hpp

@@ -21,7 +21,7 @@
 
 /// @brief Classes that implement trace filtering functions such as CARET_SELECT_NODES.
 /// @details Reads the environment variables CARET_SELECT_NODES,
-/// CARET_IGNORE_NODES, CARET_SELECT_TOPICS, and CARET_IGNORE_TOPICS.
+/// CARET_IGNORE_NODES, CARET_SELECT_TOPICS, CARET_IGNORE_TOPICS, and CARET_IGNORE_NODES.
 /// Tracepoints related to the specified node name or topic name are filtered
 /// so that they are not recorded by LTTng.
 /// If both SELECT and IGNORE are specified, SELECT takes priority.
@@ -38,6 +38,8 @@ class TracingController
   /// @param node_name Node name.
   void add_node(const void * node_handle, std::string node_name);
 
+  std::string get_node_name(const std::string type, const void * key);
+
   /// @brief Register topic name for rcl_subscription_init hook.
   /// @param node_handle Address of the node handle.
   /// @param subscription_handle Address of the subscription handle.
@@ -53,19 +55,19 @@ class TracingController
     const void * node_handle, const void * rmw_subscription_handle, std::string topic_name);
 
   /// @brief Register binding information for rclcpp_subscription_init tracepoint hook.
-  /// @param subscription_handle Address of the subscription handle.
   /// @param subscription Address of subscription instance.
-  void add_subscription(const void * subscription_handle, const void * subscription);
+  /// @param subscription_handle Address of the subscription handle.
+  void add_subscription(const void * subscription, const void * subscription_handle);
 
   /// @brief Register binding information for rclcpp_subscription_callback_added tracepoint hook.
   /// @param subscription Address of subscription instance.
   /// @param callback Address of callback instance.
   void add_subscription_callback(const void * subscription, const void * callback);
 
   /// @brief Register binding information for rclcpp_timer_link_node tracepoint hook.
-  /// @param node_handle Address of the node handle.
   /// @param timer_handle Address of the timer handle.
-  void add_timer_handle(const void * node_handle, const void * timer_handle);
+  /// @param node_handle Address of the node handle.
+  void add_timer_handle(const void * timer_handle, const void * node_handle);
 
   /// @brief Register topic name for ros_trace_rcl_publisher_init
   /// @param node_handle  Address of the node handle.
@@ -89,6 +91,26 @@ class TracingController
   /// @param subscription  Address of the subscription instance.
   void add_ipb(const void * ipb, const void * subscription);
 
+  /// @brief Register binding information for rcl_lifecycle_state_machine_init tracepoint.
+  /// @param state_machine  Address of the lifecycle state machine.
+  /// @param node_handle  Address of the node handle.
+  void add_state_machine(const void * state_machine, const void * node_handle);
+
+  /// @brief Register binding information for rclcpp_service_callback_added tracepoint.
+  /// @param service_handle  Address of the service handle.
+  /// @param node_handle  Address of the node handle instance.
+  void add_service_handle(const void * service_handle, const void * node_handle);
+
+  /// @brief Register binding information for rcl_client_init tracepoint.
+  /// @param client_handle  Address of the client handle.
+  /// @param node_handle  Address of the node handle instance.
+  void add_client_handle(const void * client_handle, const void * node_handle);
+
+  /// @brief Register binding information for intra message tracepoint.
+  /// @param message  Address of the intra original message.
+  /// @param publisher_handle  publisher_handle  Address of the publisher handle.
+  void add_message_publisher_handle(const void * message, const void * publisher_handle);
+
   /// @brief Check if trace point is a enabled callback
   /// @param callback
   /// @param callback Address of callback instance.
@@ -124,6 +146,37 @@ class TracingController
   /// @return True if the process is enabled, false otherwise.
   bool is_allowed_process();
 
+  /// @brief Check if trace point is a enabled node
+  /// @param timer_handle  Address of the timer handle.
+  /// @param callback  Address of the callback.
+  /// @return True if the timer_handle is enabled, false otherwise.
+  bool is_allowed_timer_handle(const void * timer_handle);
+
+  /// @brief Check if trace point is a enabled node
+  /// @param state_machine  Address of the lifecycle state machine.
+  /// @return True if the state_machine is enabled, false otherwise.
+  bool is_allowed_state_machine(const void * state_machine);
+
+  /// @brief Check if trace point is a enabled subscription
+  /// @param buffer Address of the intra-process buffer.
+  /// @return True if the buffer is enabled, false otherwise.
+  bool is_allowed_ipb(const void * ipb);
+
+  /// @brief Check if trace point is a enabled callback
+  /// @param service_handle Address of the service handle.
+  /// @return True if the buffer is enabled, false otherwise.
+  bool is_allowed_service_handle(const void * service_handle);
+
+  /// @brief Check if trace point is a enabled callback
+  /// @param client_handle Address of the client handle.
+  /// @return True if the buffer is enabled, false otherwise.
+  bool is_allowed_client_handle(const void * client_handle);
+
+  /// @brief Check if trace point is a enabled message
+  /// @param publisher_handle  Address of the publisher handle.
+  /// @return True if the message is enabled, false otherwise.
+  bool is_allowed_message(const void * message);
+
 private:
   void debug(std::string message) const;
   void info(std::string message) const;
@@ -149,6 +202,7 @@ class TracingController
   std::unordered_map<const void *, std::string> subscription_handle_to_topic_names_;
   std::unordered_map<const void *, const void *> subscription_to_subscription_handles_;
   std::unordered_map<const void *, const void *> callback_to_subscriptions_;
+  std::unordered_map<const void *, const void *> subscription_to_callbacks_;
 
   std::unordered_map<const void *, const void *> rmw_subscription_handle_to_node_handles_;
   std::unordered_map<const void *, std::string> rmw_subscription_handle_to_topic_names_;
@@ -158,6 +212,7 @@ class TracingController
   std::unordered_map<const void *, const void *> callback_to_timer_handles_;
   std::unordered_map<const void *, const void *> timer_handle_to_node_handles_;
   std::unordered_map<const void *, bool> allowed_callbacks_;
+  std::unordered_map<const void *, bool> allowed_timer_handles_;
 
   std::unordered_map<const void *, const void *> publisher_handle_to_node_handles_;
   std::unordered_map<const void *, std::string> publisher_handle_to_topic_names_;
@@ -166,6 +221,18 @@ class TracingController
   std::unordered_map<const void *, const void *> buffer_to_ipbs_;
   std::unordered_map<const void *, const void *> ipb_to_subscriptions_;
   std::unordered_map<const void *, bool> allowed_buffers_;
+  std::unordered_map<const void *, bool> allowed_ipbs_;
+
+  std::unordered_map<const void *, const void *> state_machine_to_node_handles_;
+  std::unordered_map<const void *, bool> allowed_state_machines_;
+
+  std::unordered_map<const void *, const void *> service_handle_to_node_handles_;
+  std::unordered_map<const void *, bool> allowed_service_handle_;
+  std::unordered_map<const void *, const void *> client_handle_to_node_handles_;
+  std::unordered_map<const void *, bool> allowed_client_handles_;
+
+  std::unordered_map<const void *, const void *> message_to_publisher_handles_;
+  std::unordered_map<const void *, bool> allowed_messages_;
 };
 
 #endif  // CARET_TRACE__TRACING_CONTROLLER_HPP_

CARET_trace/src/hooked_trace_points.cpp

@@ -262,11 +262,13 @@
     return dds_return;
   }
 
-  if (context.is_recording_allowed()) {
+  if (context.is_recording_allowed() && trace_filter_is_rcl_publish_recorded) {
     tracepoint(
       TRACEPOINT_PROVIDER, dds_bind_addr_to_stamp, serialized_message_addr, dinp->timestamp.v);
 #ifdef DEBUG_OUTPUT
-    std::cerr << "dds_bind_addr_to_stamp," << data << "," << tstamp << std::endl;
+    // std::cerr << "dds_bind_addr_to_stamp," << data << "," << tstamp << std::endl;
+    std::cerr << "dds_bind_addr_to_stamp," << serialized_message_addr << "," << dinp->timestamp.v
+              << std::endl;
 #endif
   }
   return dds_return;
@@ -278,7 +280,6 @@
   void * obj, eprosima::fastrtps::rtps::CacheChange_t * change)
 {
   static auto & context = Singleton<Context>::get_instance();
-
   using functionT = void (*)(void *, eprosima::fastrtps::rtps::CacheChange_t *);
   if (FASTDDS::SET_FRAGMENTS == nullptr) {
     update_dds_function_addr();
@@ -289,7 +290,7 @@
     return;
   }
 
-  if (context.is_recording_allowed()) {
+  if (context.is_recording_allowed() && trace_filter_is_rcl_publish_recorded) {
     tracepoint(
       TRACEPOINT_PROVIDER, dds_bind_addr_to_stamp, nullptr, change->sourceTimestamp.to_ns());
 #ifdef DEBUG_OUTPUT
@@ -312,7 +313,7 @@
 }
 
 // rclcpp::executors::SingleThreadedExecutor::SingleThreadedExecutor(rclcpp::ExecutorOptions const&)
 void _ZN6rclcpp9executors22SingleThreadedExecutorC1ERKNS_15ExecutorOptionsE(
   void * obj, const void * option)
 {
   static void * orig_func = dlsym(RTLD_NEXT, __func__);
@@ -349,7 +350,7 @@
 // std::chrono::duration<long, std::ratio<1l, 1000000000l> >)
 void SYMBOL_CONCAT_2(
   _ZN6rclcpp9executors21MultiThreadedExecutor,
   C1ERKNS_15ExecutorOptionsEmbNSt6chrono8durationIlSt5ratioILl1ELl1000000000EEEE)(
   void * obj, const void * option, size_t number_of_thread, bool yield_before_execute,
   const void * timeout)
 {
@@ -384,7 +385,7 @@
 
 // rclcpp::executors::StaticSingleThreadedExecutor::StaticSingleThreadedExecutor(
 // rclcpp::ExecutorOptions const&)
 void _ZN6rclcpp9executors28StaticSingleThreadedExecutorC1ERKNS_15ExecutorOptionsE(
   void * obj, const void * option)
 {
   static void * orig_func = dlsym(RTLD_NEXT, __func__);
@@ -421,7 +422,7 @@
   }
 
   auto entities_collector_ptr = static_cast<const void *>(exec_ptr->entities_collector_.get());
-  data_container.store_add_callback_group_static_executor(
+  data_container.store_construct_static_executor(
     obj, entities_collector_ptr, "static_single_threaded_executor", now);
   record(obj, entities_collector_ptr, "static_single_threaded_executor", now);
 }
@@ -439,28 +440,35 @@
   _ZN6rclcpp8Executor25add_callback_group_to_map,
   ESt10shared_ptrINS_13CallbackGroupEES1_INS_15node_interfaces17NodeBaseInterface,
   EERSt3mapISt8weak_ptrIS2_ES8_IS5_ESt10owner_lessIS9_ESaISt4pairIKS9_SA_EEEb)(
-  void * obj, rclcpp::CallbackGroup::SharedPtr group_ptr, const void * node_ptr,
-  const void * weak_groups_to_nodes, bool notify)
+  void * obj, rclcpp::CallbackGroup::SharedPtr group_ptr,
+  rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr, const void * weak_groups_to_nodes,
+  bool notify)
 {
   static void * orig_func = dlsym(RTLD_NEXT, __func__);
   static auto & context = Singleton<Context>::get_instance();
   static auto & clock = context.get_clock();
   static auto & data_container = context.get_data_container();
-  static auto record =
-    [](const void * obj, const void * group_addr, const char * group_type_name, int64_t init_time) {
-      tracepoint(
-        TRACEPOINT_PROVIDER, add_callback_group, obj, group_addr, group_type_name, init_time);
+  static auto record = [](
+                         const void * obj, const void * group_addr, const char * group_type_name,
+                         const void * node_handle, int64_t init_time) {
+    if (!context.get_controller().is_allowed_node(node_handle)) {
+      return;
+    }
+    tracepoint(
+      TRACEPOINT_PROVIDER, add_callback_group, obj, group_addr, group_type_name, init_time);
 
 #ifdef DEBUG_OUTPUT
-      std::cerr << "add_callback_group," << obj << "," << group_addr << "," << group_type_name
-                << std::endl;
+    std::cerr << "add_callback_group," << obj << "," << group_addr << "," << group_type_name
+              << std::endl;
 #endif
-    };
+  };
   auto now = clock.now();
 
-  using functionT =
-    void (*)(void *, rclcpp::CallbackGroup::SharedPtr, const void *, const void *, bool);
+  using functionT = void (*)(
+    void *, rclcpp::CallbackGroup::SharedPtr, rclcpp::node_interfaces::NodeBaseInterface::SharedPtr,
+    const void *, bool);
   auto group_addr = static_cast<const void *>(group_ptr.get());
+  auto node_addr = static_cast<const void *>(node_ptr.get());
 
   ((functionT)orig_func)(obj, group_ptr, node_ptr, weak_groups_to_nodes, notify);
 
@@ -474,8 +482,8 @@
 
   static KeysSet<void *, void *, void *> recorded_args;
 
-  auto node_ptr_ = const_cast<void *>(node_ptr);
   auto group_addr_ = const_cast<void *>(group_addr);
+  auto node_addr_ = const_cast<void *>(node_addr);
 
   std::string group_type_name = "unknown";
   auto group_type = group_ptr->type();
@@ -485,18 +493,20 @@
     group_type_name = "reentrant";
   }
 
-  data_container.store_add_callback_group(obj, group_addr, group_type_name.c_str(), now);
-  if (!recorded_args.has(obj, group_addr_, node_ptr_)) {
-    recorded_args.insert(obj, group_addr_, node_ptr_);
+  auto node_handle = static_cast<const void *>(node_ptr->get_rcl_node_handle());
+  data_container.store_add_callback_group(
+    obj, group_addr, group_type_name.c_str(), node_handle, now);
+  if (!recorded_args.has(obj, group_addr_, node_addr_)) {
+    recorded_args.insert(obj, group_addr_, node_addr_);
 
-    record(obj, group_addr, group_type_name.c_str(), now);
+    record(obj, group_addr, group_type_name.c_str(), node_handle, now);
   }
 }
 
 bool SYMBOL_CONCAT_3(
   _ZN6rclcpp9executors31StaticExecutorEntitiesCollector18add_callback_groupESt10shared_ptr,
   INS_13CallbackGroupEES2_INS_15node_interfaces17NodeBaseInterface,
   EERSt3mapISt8weak_ptrIS3_ES9_IS6_ESt10owner_lessISA_ESaISt4pairIKSA_SB_EEE)(
   void * obj, rclcpp::CallbackGroup::SharedPtr group_ptr,
   rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr,
   rclcpp::memory_strategy::MemoryStrategy::WeakCallbackGroupsToNodesMap & weak_groups_to_nodes)
@@ -508,17 +518,21 @@
   static auto & context = Singleton<Context>::get_instance();
   static auto & clock = context.get_clock();
   static auto & data_container = context.get_data_container();
-  static auto record =
-    [](const void * obj, const void * group_addr, const char * group_type_name, int64_t init_time) {
-      tracepoint(
-        TRACEPOINT_PROVIDER, add_callback_group_static_executor, obj, group_addr, group_type_name,
-        init_time);
+  static auto record = [](
+                         const void * obj, const void * group_addr, const char * group_type_name,
+                         const void * node_handle, int64_t init_time) {
+    if (!context.get_controller().is_allowed_node(node_handle)) {
+      return;
+    }
+    tracepoint(
+      TRACEPOINT_PROVIDER, add_callback_group_static_executor, obj, group_addr, group_type_name,
+      init_time);
 
 #ifdef DEBUG_OUTPUT
-      std::cerr << "add_callback_group_static_executor," << obj << "," << group_addr << ","
-                << group_type_name << std::endl;
+    std::cerr << "add_callback_group_static_executor," << obj << "," << group_addr << ","
+              << group_type_name << std::endl;
 #endif
-    };
+  };
 
   auto now = clock.now();
   auto group_addr = static_cast<const void *>(group_ptr.get());
@@ -540,9 +554,10 @@
     data_container.assign_add_callback_group_static_executor(record);
   }
 
+  auto node_handle = node_ptr->get_rcl_node_handle();
   data_container.store_add_callback_group_static_executor(
-    obj, group_addr, group_type_name.c_str(), now);
-  record(obj, group_addr, group_type_name.c_str(), now);
+    obj, group_addr, group_type_name.c_str(), node_handle, now);
+  record(obj, group_addr, group_type_name.c_str(), node_handle, now);
 
   return ret;
 }
@@ -558,6 +573,9 @@
   static auto & clock = context.get_clock();
   static auto & data_container = context.get_data_container();
   static auto record = [](const void * obj, const void * timer_handle, int64_t init_time) {
+    if (!context.get_controller().is_allowed_timer_handle(timer_handle)) {
+      return;
+    }
     tracepoint(TRACEPOINT_PROVIDER, callback_group_add_timer, obj, timer_handle, init_time);
 
 #ifdef DEBUG_OUTPUT
@@ -591,6 +609,9 @@
   static auto & clock = context.get_clock();
   static auto & data_container = context.get_data_container();
   static auto record = [](const void * obj, const void * subscription_handle, int64_t init_time) {
+    if (!context.get_controller().is_allowed_subscription_handle(subscription_handle)) {
+      return;
+    }
     tracepoint(
       TRACEPOINT_PROVIDER, callback_group_add_subscription, obj, subscription_handle, init_time);
 
@@ -627,6 +648,9 @@
   static auto & clock = context.get_clock();
   static auto & data_container = context.get_data_container();
   static auto record = [](const void * obj, const void * service_handle, int64_t init_time) {
+    if (!context.get_controller().is_allowed_service_handle(service_handle)) {
+      return;
+    }
     tracepoint(TRACEPOINT_PROVIDER, callback_group_add_service, obj, service_handle, init_time);
 
 #ifdef DEBUG_OUTPUT
@@ -660,6 +684,9 @@
   static auto & clock = context.get_clock();
   static auto & data_container = context.get_data_container();
   static auto record = [](const void * obj, const void * client_handle, int64_t init_time) {
+    if (!context.get_controller().is_allowed_client_handle(client_handle)) {
+      return;
+    }
     tracepoint(TRACEPOINT_PROVIDER, callback_group_add_client, obj, client_handle, init_time);
 
 #ifdef DEBUG_OUTPUT