grpc 1.76.0 → 1.78.0.pre1

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,6 +351,15 @@ 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) {}
@@ -312,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)                            \
@@ -325,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), \
@@ -335,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
@@ -344,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)
@@ -372,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 {                              \
@@ -379,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 "src/core/util/grpc_check.h"
 
 namespace grpc_core {
 

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 {
 

data/src/core/util/memory_usage.h

@@ -23,14 +23,14 @@
 #include <utility>
 #include <vector>
 
+#include "src/core/lib/slice/slice.h"
+#include "src/core/lib/slice/slice_buffer.h"
+#include "src/core/util/time.h"
 #include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 #include "absl/time/time.h"
-#include "src/core/lib/slice/slice.h"
-#include "src/core/lib/slice/slice_buffer.h"
-#include "src/core/util/time.h"
 
 namespace grpc_core {
 

data/src/core/util/mpscq.h

@@ -23,8 +23,8 @@
 
 #include <atomic>
 
-#include "absl/log/check.h"
 #include "src/core/util/sync.h"
+#include "absl/log/check.h"
 
 namespace grpc_core {
 

data/src/core/util/notification.h

@@ -17,9 +17,9 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/util/sync.h"
 #include "absl/time/clock.h"
 #include "absl/time/time.h"
-#include "src/core/util/sync.h"
 
 namespace grpc_core {
 

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

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

data/src/core/util/posix/stat.cc

@@ -27,10 +27,10 @@
 #include <errno.h>
 #include <sys/stat.h>
 
-#include "absl/log/check.h"
-#include "absl/log/log.h"
 #include "src/core/util/stat.h"
 #include "src/core/util/strerror.h"
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 
 namespace grpc_core {
 

data/src/core/util/posix/thd.cc

@@ -34,13 +34,13 @@
 #include <string.h>
 #include <unistd.h>
 
-#include "absl/log/check.h"
-#include "absl/log/log.h"
 #include "src/core/util/crash.h"
 #include "src/core/util/fork.h"
 #include "src/core/util/strerror.h"
 #include "src/core/util/thd.h"
 #include "src/core/util/useful.h"
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 
 namespace grpc_core {
 namespace {

data/src/core/util/posix/tmpfile.cc

@@ -27,12 +27,12 @@
 #include <string.h>
 #include <unistd.h>
 
-#include "absl/log/check.h"
-#include "absl/log/log.h"
 #include "src/core/util/crash.h"
 #include "src/core/util/strerror.h"
 #include "src/core/util/string.h"
 #include "src/core/util/tmpfile.h"
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 
 FILE* gpr_tmpfile(const char* prefix, char** tmp_filename) {
   FILE* result = nullptr;

data/src/core/util/ref_counted.h

@@ -25,12 +25,12 @@
 #include <cassert>
 #include <cinttypes>
 
-#include "absl/log/check.h"
-#include "absl/log/log.h"
 #include "src/core/util/atomic_utils.h"
 #include "src/core/util/debug_location.h"
 #include "src/core/util/down_cast.h"
 #include "src/core/util/ref_counted_ptr.h"
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 
 namespace grpc_core {
 

data/src/core/util/ref_counted_ptr.h

@@ -26,9 +26,9 @@
 #include <type_traits>
 #include <utility>
 
-#include "absl/hash/hash.h"
 #include "src/core/util/debug_location.h"
 #include "src/core/util/down_cast.h"
+#include "absl/hash/hash.h"
 
 namespace grpc_core {
 

data/src/core/util/ref_counted_string.h

@@ -22,9 +22,9 @@
 
 #include <string>
 
-#include "absl/strings/string_view.h"
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/ref_counted_ptr.h"
+#include "absl/strings/string_view.h"
 
 namespace grpc_core {
 

data/src/core/util/single_set_ptr.h

@@ -20,8 +20,8 @@
 #include <atomic>
 #include <memory>
 
-#include "absl/log/check.h"
 #include "src/core/util/ref_counted_ptr.h"
+#include "absl/log/check.h"
 
 namespace grpc_core {
 
@@ -60,6 +60,8 @@ class SingleSetPtr {
   T* Set(std::unique_ptr<T, Deleter> ptr) { return Set(ptr.release()); }
 
   // Clear the pointer.
+  // Caller must ensure that no other thread is concurrently trying to set the
+  // pointer, or read the pointer.
   void Reset() { Delete(p_.exchange(nullptr, std::memory_order_acq_rel)); }
 
   bool is_set() const { return p_.load(std::memory_order_relaxed) != nullptr; }

data/src/core/util/status_helper.cc

@@ -23,14 +23,6 @@
 
 #include <utility>
 
-#include "absl/log/check.h"
-#include "absl/strings/cord.h"
-#include "absl/strings/escaping.h"
-#include "absl/strings/match.h"
-#include "absl/strings/numbers.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/str_join.h"
-#include "absl/time/clock.h"
 #include "google/protobuf/any.upb.h"
 #include "google/rpc/status.upb.h"
 #include "src/core/lib/experiments/experiments.h"
@@ -40,6 +32,14 @@
 #include "src/core/util/time.h"
 #include "upb/base/string_view.h"
 #include "upb/mem/arena.hpp"
+#include "absl/log/check.h"
+#include "absl/strings/cord.h"
+#include "absl/strings/escaping.h"
+#include "absl/strings/match.h"
+#include "absl/strings/numbers.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_join.h"
+#include "absl/time/clock.h"
 
 namespace grpc_core {
 

data/src/core/util/status_helper.h

@@ -26,10 +26,10 @@
 #include <string>
 #include <vector>
 
+#include "src/core/util/debug_location.h"
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
 #include "absl/time/time.h"
-#include "src/core/util/debug_location.h"
 
 extern "C" {
 struct google_rpc_Status;

data/src/core/util/string.cc

@@ -29,10 +29,10 @@
 #include <string.h>
 #include <time.h>
 
-#include "absl/strings/str_cat.h"
-#include "absl/time/time.h"
 #include "src/core/util/crash.h"
 #include "src/core/util/useful.h"
+#include "absl/strings/str_cat.h"
+#include "absl/time/time.h"
 
 char* gpr_strdup(const char* src) {
   char* dst;

data/src/core/util/sync_abseil.cc

@@ -26,11 +26,11 @@
 #include <grpc/support/time.h>
 #include <time.h>
 
+#include "src/core/util/time_util.h"
 #include "absl/base/call_once.h"
 #include "absl/synchronization/mutex.h"
 #include "absl/time/clock.h"
 #include "absl/time/time.h"
-#include "src/core/util/time_util.h"
 
 void gpr_mu_init(gpr_mu* mu) {
   static_assert(sizeof(gpr_mu) == sizeof(absl::Mutex),

data/src/core/util/table.h

@@ -23,9 +23,9 @@
 #include <type_traits>
 #include <utility>
 
+#include "src/core/util/bitset.h"
 #include "absl/meta/type_traits.h"
 #include "absl/utility/utility.h"
-#include "src/core/util/bitset.h"
 
 namespace grpc_core {
 

data/src/core/util/time.cc

@@ -23,10 +23,10 @@
 #include <string>
 #include <utility>
 
+#include "src/core/util/no_destruct.h"
 #include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/strings/str_format.h"
-#include "src/core/util/no_destruct.h"
 
 // IWYU pragma: no_include <ratio>