grpc 1.75.0 → 1.78.1

data/src/core/util/json/json_reader.cc

@@ -26,6 +26,8 @@
 #include <variant>
 #include <vector>
 
+#include "src/core/util/json/json.h"
+#include "src/core/util/match.h"
 #include "absl/base/attributes.h"
 #include "absl/log/check.h"
 #include "absl/status/status.h"
@@ -34,8 +36,6 @@
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
 #include "absl/strings/string_view.h"
-#include "src/core/util/json/json.h"
-#include "src/core/util/match.h"
 
 #define GRPC_JSON_MAX_DEPTH 255
 #define GRPC_JSON_MAX_ERRORS 16

data/src/core/util/json/json_reader.h

@@ -19,9 +19,9 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/util/json/json.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
-#include "src/core/util/json/json.h"
 
 namespace grpc_core {
 

data/src/core/util/json/json_util.h

@@ -28,12 +28,12 @@
 #include <utility>
 #include <vector>
 
-#include "absl/strings/numbers.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/string_view.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/util/json/json.h"
 #include "src/core/util/time.h"
+#include "absl/strings/numbers.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
 
 namespace grpc_core {
 

data/src/core/util/json/json_writer.cc

@@ -25,8 +25,8 @@
 #include <utility>
 #include <vector>
 
-#include "absl/strings/string_view.h"
 #include "src/core/util/json/json.h"
+#include "absl/strings/string_view.h"
 
 namespace grpc_core {
 

data/src/core/util/latent_see.cc

@@ -16,15 +16,19 @@
 
 #include <atomic>
 #include <cstdint>
+#include <cstdlib>
 #include <memory>
 #include <string>
 #include <vector>
 
-#include "absl/log/log.h"
-#include "absl/strings/str_cat.h"
+#include "src/core/channelz/property_list.h"
 #include "src/core/util/backoff.h"
+#include "src/core/util/json/json.h"
+#include "src/core/util/json/json_writer.h"
 #include "src/core/util/notification.h"
 #include "src/core/util/sync.h"
+#include "absl/log/log.h"
+#include "absl/strings/str_cat.h"
 
 namespace grpc_core::latent_see {
 
@@ -38,10 +42,13 @@ std::string JsonOutput::MicrosString(int64_t nanos) {
   return absl::StrFormat("%d.%03d", micros, remainder);
 }
 
-void JsonOutput::Mark(absl::string_view name, int64_t tid, int64_t timestamp) {
+void JsonOutput::Mark(absl::string_view name, int64_t tid, int64_t timestamp,
+                      channelz::PropertyList property_list) {
+  auto properties_json = Json::FromObject(property_list.TakeJsonObject());
   out_ << absl::StrCat(sep_, "{\"name\":\"", name,
                        "\",\"ph\":\"i\",\"ts\":", MicrosString(timestamp),
-                       ",\"pid\":0,\"tid\":", tid, "}");
+                       ",\"pid\":0,\"tid\":", tid,
+                       ",\"args\":", JsonDump(properties_json), "}");
   sep_ = ",\n";
 }
 
@@ -55,9 +62,10 @@ void JsonOutput::FlowBegin(absl::string_view name, int64_t tid,
 
 void JsonOutput::FlowEnd(absl::string_view name, int64_t tid, int64_t timestamp,
                          int64_t flow_id) {
-  out_ << absl::StrCat(sep_, "{\"name\":\"", name,
-                       "\",\"ph\":\"f\",\"ts\":", MicrosString(timestamp),
-                       ",\"pid\":0,\"tid\":", tid, ",\"id\":", flow_id, "}");
+  out_ << absl::StrCat(
+      sep_, "{\"name\":\"", name,
+      "\",\"ph\":\"f\",\"bp\":\"e\",\"ts\":", MicrosString(timestamp),
+      ",\"pid\":0,\"tid\":", tid, ",\"id\":", flow_id, "}");
   sep_ = ",\n";
 }
 
@@ -130,7 +138,7 @@ std::unique_ptr<Sink::EventDump> Sink::Stop() {
 void Sink::Record(std::unique_ptr<Bin> bin) {
   MutexLock lock(&mu_);
   if (events_ == nullptr) return;
-  CHECK_LE(bin->num_events, Bin::kEventsPerBin);
+  CHECK_LE(bin->used_space, Bin::kMaxBinSize);
   events_->emplace_back(std::move(bin));
   if (events_->size() > max_bins_) events_->pop_front();
 }
@@ -177,11 +185,16 @@ void Collect(Notification* n, absl::Duration timeout, size_t memory_limit,
         earliest_timestamp = std::min(
             {earliest_timestamp, event.timestamp_begin, event.timestamp_end});
       } else {
-        earliest_timestamp = std::min(earliest_timestamp, -event.timestamp_end);
+        earliest_timestamp =
+            std::min(earliest_timestamp, abs(event.timestamp_end));
       }
     }
   }
   std::string json = "[\n";
+  // Add a mark for the actual timestamp when collection started.
+  output->Mark(
+      "LatentseeCollectionStart", /*tid=*/0, /*timestamp=*/0,
+      channelz::PropertyList().Set("actual_start_time", earliest_timestamp));
   // TODO(ctiller): Fuschia Trace Format backend
   absl::flat_hash_map<gpr_thd_id, size_t> thread_id_map;
   for (const auto& bin : *events) {
@@ -193,22 +206,30 @@ void Collect(Notification* n, absl::Duration timeout, size_t memory_limit,
     } else {
       displayed_thread_id = it->second;
     }
-    for (const auto& event : *bin) {
-      if (event.timestamp_begin == event.timestamp_end) {
-        output->Mark(event.metadata->name, displayed_thread_id,
-                     event.timestamp_begin - earliest_timestamp);
-      } else if (event.timestamp_begin < 0 && event.timestamp_end > 0) {
-        output->FlowBegin(event.metadata->name, displayed_thread_id,
-                          event.timestamp_end - earliest_timestamp,
-                          -event.timestamp_begin);
-      } else if (event.timestamp_begin < 0) {
-        output->FlowEnd(event.metadata->name, displayed_thread_id,
-                        -event.timestamp_end - earliest_timestamp,
-                        -event.timestamp_begin);
+    for (auto it = bin->begin(); it != bin->end(); ++it) {
+      if (it->timestamp_begin == it->timestamp_end) {
+        if (it->metadata->extra_event_size > 0) {
+          output->Mark(
+              it->metadata->name, displayed_thread_id,
+              it->timestamp_begin - earliest_timestamp,
+              it->metadata->to_property_list(it.ptr() + sizeof(Bin::Event)));
+        } else {
+          output->Mark(it->metadata->name, displayed_thread_id,
+                       it->timestamp_begin - earliest_timestamp,
+                       channelz::PropertyList());
+        }
+      } else if (it->timestamp_begin < 0 && it->timestamp_end > 0) {
+        output->FlowBegin(it->metadata->name, displayed_thread_id,
+                          it->timestamp_end - earliest_timestamp,
+                          -it->timestamp_begin);
+      } else if (it->timestamp_begin < 0) {
+        output->FlowEnd(it->metadata->name, displayed_thread_id,
+                        -it->timestamp_end - earliest_timestamp,
+                        -it->timestamp_begin);
       } else {
-        output->Span(event.metadata->name, displayed_thread_id,
-                     event.timestamp_begin - earliest_timestamp,
-                     event.timestamp_end - event.timestamp_begin);
+        output->Span(it->metadata->name, displayed_thread_id,
+                     it->timestamp_begin - earliest_timestamp,
+                     it->timestamp_end - it->timestamp_begin);
       }
     }
   }

data/src/core/util/latent_see.h

@@ -19,25 +19,32 @@
 #include <grpc/support/thd_id.h>
 
 #include <atomic>
+#include <cstddef>
 #include <cstdint>
 #include <cstdio>
 #include <cstdlib>
+#include <iterator>
 #include <memory>
+#include <string>
 #include <utility>
 
-#include "absl/container/flat_hash_map.h"
-#include "absl/strings/string_view.h"
-#include "absl/time/clock.h"
+#include "src/core/channelz/property_list.h"
+#include "src/core/util/alloc.h"
+#include "src/core/util/function_signature.h"
 #include "src/core/util/mpscq.h"
 #include "src/core/util/notification.h"
 #include "src/core/util/thd.h"
+#include "absl/container/flat_hash_map.h"
+#include "absl/strings/string_view.h"
+#include "absl/time/clock.h"
 
 namespace grpc_core {
 namespace latent_see {
 
 class Output {
  public:
-  virtual void Mark(absl::string_view name, int64_t tid, int64_t timestamp) = 0;
+  virtual void Mark(absl::string_view name, int64_t tid, int64_t timestamp,
+                    channelz::PropertyList property_list) = 0;
   virtual void FlowBegin(absl::string_view name, int64_t tid, int64_t timestamp,
                          int64_t flow_id) = 0;
   virtual void FlowEnd(absl::string_view name, int64_t tid, int64_t timestamp,
@@ -52,7 +59,8 @@ class Output {
 
 class DiscardOutput final : public Output {
  public:
-  void Mark(absl::string_view, int64_t, int64_t) override {}
+  void Mark(absl::string_view, int64_t, int64_t,
+            channelz::PropertyList) override {}
   void FlowBegin(absl::string_view, int64_t, int64_t, int64_t) override {}
   void FlowEnd(absl::string_view, int64_t, int64_t, int64_t) override {}
   void Span(absl::string_view, int64_t, int64_t, int64_t) override {}
@@ -63,7 +71,8 @@ class JsonOutput final : public Output {
  public:
   explicit JsonOutput(std::ostream& out) : out_(out) { out_ << "[\n"; }
 
-  void Mark(absl::string_view name, int64_t tid, int64_t timestamp) override;
+  void Mark(absl::string_view name, int64_t tid, int64_t timestamp,
+            channelz::PropertyList property_list) override;
   void FlowBegin(absl::string_view name, int64_t tid, int64_t timestamp,
                  int64_t flow_id) override;
   void FlowEnd(absl::string_view name, int64_t tid, int64_t timestamp,
@@ -91,11 +100,14 @@ struct Metadata {
   const char* file;
   int line;
   absl::string_view name;
+  int extra_event_size;
+  void (*destruct_extra_event)(void* extra_event);
+  channelz::PropertyList (*to_property_list)(void* extra_event);
 };
 
 // A bin collects all events that occur within a parent scope.
 struct Bin : public MultiProducerSingleConsumerQueue::Node {
-  struct Event {
+  struct alignas(GPR_MAX_ALIGNMENT) Event {
     const Metadata* metadata;
     int64_t timestamp_begin;
     int64_t timestamp_end;
@@ -103,24 +115,109 @@ struct Bin : public MultiProducerSingleConsumerQueue::Node {
     static constexpr uint64_t kSpan = 0;
     static constexpr uint64_t kFlow = 1;
   };
+  enum class AppendResult : uint8_t {
+    kSuccess = 0,
+    kFailed = 1,
+    kFull = 2,
+  };
+  class Iterator {
+   public:
+    // Type definitions required by STL
+    using value_type = Event;
+    using pointer = Event*;
+    using reference = Event&;
+    using difference_type = std::ptrdiff_t;
+    using iterator_category = std::forward_iterator_tag;  // Or other categories
+
+    // Constructor
+    explicit Iterator(const uint8_t* ptr) : ptr_(ptr) {}
+
+    // Dereference operator
+    const Event& operator*() const {
+      return *reinterpret_cast<const Event*>(ptr_);
+    }
+    const Event* operator->() const {
+      return reinterpret_cast<const Event*>(ptr_);
+    }
 
-  bool Append(const Metadata* metadata, int64_t timestamp_begin,
-              int64_t timestamp_end) {
-    Event* ev = &events[num_events];
-    ++num_events;
+    uint8_t* ptr() const { return const_cast<uint8_t*>(ptr_); }
+
+    // Increment operators
+    Iterator& operator++() {  // Pre-increment
+      const Event* curr_event = reinterpret_cast<const Event*>(ptr_);
+      if (curr_event->metadata->extra_event_size == 0) {
+        ptr_ += sizeof(Event);
+      } else {
+        ptr_ += curr_event->metadata->extra_event_size + sizeof(Event);
+      }
+      return *this;
+    }
+    Iterator operator++(int) {  // Post-increment
+      Iterator temp = *this;
+      operator++();
+      return temp;
+    }
+
+    // Comparison operators
+    bool operator==(const Iterator& other) const { return ptr_ == other.ptr_; }
+    bool operator!=(const Iterator& other) const { return ptr_ != other.ptr_; }
+
+   private:
+    const uint8_t* ptr_;
+  };
+
+  AppendResult Append(const Metadata* metadata, int64_t timestamp_begin,
+                      int64_t timestamp_end) {
+    Event* ev = reinterpret_cast<Event*>(&events[used_space]);
+    if (used_space + sizeof(Event) > kMaxBinSize) {
+      // No space left in the bin to append the event.
+      return AppendResult::kFailed;
+    }
+    ev->metadata = metadata;
+    ev->timestamp_begin = timestamp_begin;
+    ev->timestamp_end = timestamp_end;
+    used_space += sizeof(Event);
+    return used_space == kMaxBinSize ? AppendResult::kFull
+                                     : AppendResult::kSuccess;
+  }
+
+  template <typename X>
+  AppendResult Append(const Metadata* metadata, int64_t timestamp_begin,
+                      int64_t timestamp_end, const X& x) {
+    if (used_space + sizeof(Event) +
+            GPR_ROUND_UP_TO_ALIGNMENT_SIZE(metadata->extra_event_size) >
+        kMaxBinSize) {
+      // No space left in the bin to append this event.
+      return AppendResult::kFailed;
+    }
+    uint8_t* ptr = &events[used_space];
+    // Copy construct the extra_event in the space immediately after this
+    // Event struct.
+    new (reinterpret_cast<void*>(ptr + sizeof(Event))) X(x);
+    Event* ev = reinterpret_cast<Event*>(ptr);
     ev->metadata = metadata;
     ev->timestamp_begin = timestamp_begin;
     ev->timestamp_end = timestamp_end;
-    return num_events == kEventsPerBin;
+    used_space += sizeof(Event) + metadata->extra_event_size;
+    return used_space == kMaxBinSize ? AppendResult::kFull
+                                     : AppendResult::kSuccess;
   }
 
-  const Event* begin() const { return events.data(); }
-  const Event* end() const { return events.data() + num_events; }
+  ~Bin() {
+    for (auto it = this->begin(); it != this->end(); ++it) {
+      if (it->metadata->extra_event_size > 0) {
+        it->metadata->destruct_extra_event(it.ptr() + sizeof(Event));
+      }
+    }
+  }
 
-  static constexpr size_t kEventsPerBin = 8192 / sizeof(Event) - 1;
-  size_t num_events = 0;
+  Iterator begin() const { return Iterator(&events[0]); }
+  Iterator end() const { return Iterator(&events[used_space]); }
+  static constexpr size_t kMaxBinSize = 8192;
+  static constexpr size_t kEventsPerBin = kMaxBinSize / sizeof(Event);
+  size_t used_space = 0;
   gpr_thd_id thd_id = gpr_thd_currentid();
-  std::array<Event, kEventsPerBin> events;
+  alignas(Event) uint8_t events[kMaxBinSize];
 };
 
 void Collect(Notification* notification, absl::Duration timeout,
@@ -166,8 +263,38 @@ class Appender {
               int64_t timestamp_end) {
     DCHECK(Enabled());
     DCHECK_NE(metadata, nullptr);
-    if (GPR_UNLIKELY(bin_ == nullptr)) bin_ = std::make_unique<Bin>();
-    if (GPR_UNLIKELY(bin_->Append(metadata, timestamp_begin, timestamp_end))) {
+    Bin::AppendResult result;
+    do {
+      if (GPR_UNLIKELY(bin_ == nullptr)) bin_ = std::make_unique<Bin>();
+      result = bin_->Append(metadata, timestamp_begin, timestamp_end);
+      if (GPR_UNLIKELY(result == Bin::AppendResult::kFailed)) {
+        sink_->Append(std::move(bin_));
+        // Retry with a new bin.
+        bin_ = nullptr;
+      }
+    } while (result == Bin::AppendResult::kFailed);
+
+    if (GPR_UNLIKELY(result == Bin::AppendResult::kFull)) {
+      sink_->Append(std::move(bin_));
+    }
+  }
+  template <typename X>
+  void Append(const Metadata* metadata, int64_t timestamp_begin,
+              int64_t timestamp_end, const X& x) {
+    DCHECK(Enabled());
+    DCHECK_NE(metadata, nullptr);
+    Bin::AppendResult result;
+    do {
+      if (GPR_UNLIKELY(bin_ == nullptr)) bin_ = std::make_unique<Bin>();
+      result = bin_->Append(metadata, timestamp_begin, timestamp_end, x);
+      if (GPR_UNLIKELY(result == Bin::AppendResult::kFailed)) {
+        sink_->Append(std::move(bin_));
+        // Retry with a new bin.
+        bin_ = nullptr;
+      }
+    } while (result == Bin::AppendResult::kFailed);
+
+    if (GPR_UNLIKELY(result == Bin::AppendResult::kFull)) {
       sink_->Append(std::move(bin_));
     }
   }
@@ -224,16 +351,25 @@ GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static inline void Mark(
   appender.Append(metadata, ts, ts);
 }
 
+template <typename X>
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static inline void MarkExtraEvent(
+    const Metadata* metadata, const X& x) {
+  Appender appender;
+  if (GPR_LIKELY(!appender.Enabled())) return;
+  const auto ts = absl::GetCurrentTimeNanos();
+  appender.Append(metadata, ts, ts, x);
+}
+
 class Flow {
  public:
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Flow() : id_(0) {}
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION explicit Flow(const Metadata* metadata) {
     Appender appender;
+    metadata_ = metadata;
     if (GPR_LIKELY(!appender.Enabled())) {
       id_ = 0;
       return;
     }
-    metadata_ = metadata;
     AppendBegin(appender);
   }
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION ~Flow() {
@@ -248,11 +384,11 @@ class Flow {
   Flow(Flow&& other) noexcept
       : metadata_(other.metadata_), id_(std::exchange(other.id_, 0)) {}
   Flow& operator=(Flow&& other) noexcept {
+    metadata_ = other.metadata_;
     if (id_ != 0) {
       Appender appender;
       if (GPR_LIKELY(!appender.Enabled())) AppendEnd(appender);
     }
-    metadata_ = other.metadata_;
     id_ = std::exchange(other.id_, 0);
     return *this;
   }
@@ -273,7 +409,10 @@ class Flow {
     metadata_ = metadata;
     AppendBegin(appender);
   }
-  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION void Begin() { Begin(metadata_); }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION void Begin() {
+    DCHECK(metadata_ != nullptr);
+    Begin(metadata_);
+  }
 
  private:
   void AppendBegin(Appender& appender) {
@@ -285,7 +424,7 @@ class Flow {
     appender.Append(metadata_, -id_, -absl::GetCurrentTimeNanos());
     id_ = 0;
   }
-  const Metadata* metadata_;
+  const Metadata* metadata_ = nullptr;
   static inline std::atomic<int64_t> next_id_{1};
   int64_t id_;
 };
@@ -309,11 +448,29 @@ GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION auto Promise(const Metadata* md_poll,
 #define GRPC_LATENT_SEE_SYMBOL2(name, line) name##_##line
 #define GRPC_LATENT_SEE_SYMBOL1(name, line) GRPC_LATENT_SEE_SYMBOL2(name, line)
 #define GRPC_LATENT_SEE_SYMBOL(name) GRPC_LATENT_SEE_SYMBOL1(name, __LINE__)
-#define GRPC_LATENT_SEE_METADATA(name)                                     \
-  []() {                                                                   \
-    static grpc_core::latent_see::Metadata metadata = {__FILE__, __LINE__, \
-                                                       name};              \
-    return &metadata;                                                      \
+#define GRPC_LATENT_SEE_METADATA(name)                  \
+  []() {                                                \
+    static grpc_core::latent_see::Metadata metadata = { \
+        __FILE__, __LINE__, name, 0, nullptr, nullptr}; \
+    return &metadata;                                   \
+  }()
+// NOLINTNEXTLINE(bugprone-macro-parentheses)
+#define GRPC_LATENT_SEE_EXTRA_EVENT_METADATA(type)                           \
+  []() {                                                                     \
+    static grpc_core::latent_see::Metadata metadata = {                      \
+        __FILE__,                                                            \
+        __LINE__,                                                            \
+        TypeName<type>(),                                                    \
+        GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(type)),                        \
+        [](void* extra_event) {                                              \
+          /* NOLINTNEXTLINE(bugprone-macro-parentheses)  */                  \
+          reinterpret_cast<type*>(extra_event)->~type();                     \
+        },                                                                   \
+        [](void* extra_event) {                                              \
+          /* NOLINTNEXTLINE(bugprone-macro-parentheses)  */                  \
+          return reinterpret_cast<type*>(extra_event)->ChannelzProperties(); \
+        }};                                                                  \
+    return &metadata;                                                        \
   }()
 // Scope: marks a begin/end event in the log.
 #define GRPC_LATENT_SEE_ALWAYS_ON_SCOPE(name)                            \
@@ -322,6 +479,9 @@ GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION auto Promise(const Metadata* md_poll,
 // Mark: logs a single event.
 #define GRPC_LATENT_SEE_ALWAYS_ON_MARK(name) \
   grpc_core::latent_see::Mark(GRPC_LATENT_SEE_METADATA(name))
+#define GRPC_LATENT_SEE_ALWAYS_ON_MARK_EXTRA_EVENT(type, extra_event) \
+  grpc_core::latent_see::MarkExtraEvent(                              \
+      GRPC_LATENT_SEE_EXTRA_EVENT_METADATA(type), extra_event)
 #define GRPC_LATENT_SEE_ALWAYS_ON_PROMISE(name, promise)                      \
   grpc_core::latent_see::Promise(                                             \
       GRPC_LATENT_SEE_METADATA("Poll:" name), GRPC_LATENT_SEE_METADATA(name), \
@@ -332,6 +492,8 @@ GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION auto Promise(const Metadata* md_poll,
 #ifdef GRPC_EXTRA_LATENT_SEE
 #define GRPC_LATENT_SEE_SCOPE(name) GRPC_LATENT_SEE_ALWAYS_ON_SCOPE(name)
 #define GRPC_LATENT_SEE_MARK(name) GRPC_LATENT_SEE_ALWAYS_ON_MARK(name)
+#define GRPC_LATENT_SEE_MARK_EXTRA_EVENT(type, extra_event) \
+  GRPC_LATENT_SEE_ALWAYS_ON_MARK_EXTRA_EVENT(type, extra_event)
 #define GRPC_LATENT_SEE_PROMISE(name, promise) \
   GRPC_LATENT_SEE_ALWAYS_ON_PROMISE(name, promise)
 #else
@@ -341,6 +503,9 @@ GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION auto Promise(const Metadata* md_poll,
 #define GRPC_LATENT_SEE_MARK(name) \
   do {                             \
   } while (0)
+#define GRPC_LATENT_SEE_MARK_EXTRA_EVENT(type, extra_event) \
+  do {                                                      \
+  } while (0)
 #define GRPC_LATENT_SEE_PROMISE(name, promise) promise
 #endif
 #else  // def(GRPC_DISABLE_LATENT_SEE)
@@ -369,6 +534,9 @@ inline void Collect(Notification*, absl::Duration, size_t, Output* output) {
 #define GRPC_LATENT_SEE_ALWAYS_ON_MARK(name) \
   do {                                       \
   } while (0)
+#define GRPC_LATENT_SEE_ALWAYS_ON_MARK_EXTRA_EVENT(type, extra_event) \
+  do {                                                                \
+  } while (0)
 #define GRPC_LATENT_SEE_ALWAYS_ON_PROMISE(name, promise) promise
 #define GRPC_LATENT_SEE_SCOPE(name) \
   do {                              \
@@ -376,6 +544,9 @@ inline void Collect(Notification*, absl::Duration, size_t, Output* output) {
 #define GRPC_LATENT_SEE_MARK(name) \
   do {                             \
   } while (0)
+#define GRPC_LATENT_MARK_EXTRA_EVENT(type, extra_event) \
+  do {                                                  \
+  } while (0)
 #define GRPC_LATENT_SEE_PROMISE(name, promise) promise
 #endif  // GRPC_DISABLE_LATENT_SEE
 

data/src/core/util/linux/cpu.cc

@@ -31,9 +31,9 @@
 #include <string.h>
 #include <unistd.h>
 
-#include "absl/log/log.h"
 #include "src/core/util/crash.h"
 #include "src/core/util/strerror.h"
+#include "absl/log/log.h"
 
 static int ncpus = 0;
 

data/src/core/util/load_file.cc

@@ -21,10 +21,10 @@
 #include <stdio.h>
 #include <string.h>
 
+#include "src/core/util/strerror.h"
 #include "absl/cleanup/cleanup.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
-#include "src/core/util/strerror.h"
 
 namespace grpc_core {
 

data/src/core/util/load_file.h

@@ -19,8 +19,8 @@
 
 #include <string>
 
-#include "absl/status/statusor.h"
 #include "src/core/lib/slice/slice.h"
+#include "absl/status/statusor.h"
 
 namespace grpc_core {
 

data/src/core/util/log.cc

@@ -25,13 +25,13 @@
 #include <stdio.h>
 #include <string.h>
 
+#include "src/core/config/config_vars.h"
+#include "src/core/util/crash.h"
+#include "src/core/util/string.h"
 #include "absl/log/check.h"
 #include "absl/log/globals.h"
 #include "absl/strings/match.h"
 #include "absl/strings/str_cat.h"
-#include "src/core/config/config_vars.h"
-#include "src/core/util/crash.h"
-#include "src/core/util/string.h"
 
 void gpr_unreachable_code(const char* reason, const char* file, int line) {
   grpc_core::Crash(absl::StrCat("UNREACHABLE CODE: ", reason),

data/src/core/util/lru_cache.h

@@ -22,9 +22,9 @@
 #include <tuple>
 #include <utility>
 
+#include "src/core/util/grpc_check.h"
 #include "absl/container/flat_hash_map.h"
 #include "absl/functional/any_invocable.h"
-#include "absl/log/check.h"
 
 namespace grpc_core {
 
@@ -35,7 +35,7 @@ template <typename Key, typename Value>
 class LruCache {
  public:
   explicit LruCache(size_t max_size) : max_size_(max_size) {
-    CHECK_GT(max_size, 0UL);
+    GRPC_CHECK_GT(max_size, 0UL);
   }
 
   // Returns the value for key, or nullopt if not present.
@@ -110,9 +110,9 @@ void LruCache<Key, Value>::SetMaxSize(size_t max_size) {
 template <typename Key, typename Value>
 void LruCache<Key, Value>::RemoveOldestEntry() {
   auto lru_it = lru_list_.begin();
-  CHECK(lru_it != lru_list_.end());
+  GRPC_CHECK(lru_it != lru_list_.end());
   auto cache_it = cache_.find(*lru_it);
-  CHECK(cache_it != cache_.end());
+  GRPC_CHECK(cache_it != cache_.end());
   cache_.erase(cache_it);
   lru_list_.pop_front();
 }

data/src/core/util/matchers.h

@@ -22,9 +22,9 @@
 #include <optional>
 #include <string>
 
+#include "re2/re2.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
-#include "re2/re2.h"
 
 namespace grpc_core {