grpc 1.68.1 → 1.69.0.pre1

data/src/core/util/latent_see.cc

@@ -35,88 +35,109 @@ thread_local Bin* Log::bin_ = nullptr;
 thread_local void* Log::bin_owner_ = nullptr;
 std::atomic<uint64_t> Flow::next_flow_id_{1};
 std::atomic<uintptr_t> Log::free_bins_{0};
+const std::chrono::steady_clock::time_point start_time =
+    std::chrono::steady_clock::now();
 
-std::string Log::GenerateJson() {
-  std::vector<RecordedEvent> events;
-  RingBuffer<RecordedEvent, Log::kMaxEventsPerCpu>* other;
-  for (auto& fragment : fragments_) {
-    {
-      MutexLock lock(&fragment.mu);
-      other = fragment.active;
-      if (fragment.active == &fragment.primary) {
-        fragment.active = &fragment.secondary;
-      } else {
-        fragment.active = &fragment.primary;
-      }
+void Log::TryPullEventsAndFlush(
+    absl::FunctionRef<void(absl::Span<const RecordedEvent>)> callback) {
+  // Try to lock... if we fail then clear the active events.
+  // This guarantees freeing up memory even if we're still serializing the
+  // previous pull.
+  if (!mu_flushing_.TryLock()) {
+    for (auto& fragment : fragments_) {
+      MutexLock lock(&fragment.mu_active);
+      fragment.active.clear();
     }
-    for (auto it = other->begin(); it != other->end(); ++it) {
-      events.push_back(*it);
-    }
-    other->Clear();
+    return;
   }
-  absl::optional<std::chrono::steady_clock::time_point> start_time;
-  for (auto& event : events) {
-    if (!start_time.has_value() || *start_time > event.event.timestamp) {
-      start_time = event.event.timestamp;
-    }
+  // Now we hold the lock; swap all active fragments to flushing.
+  // This is relatively quick and ensures that we don't stall capture for
+  // long.
+  for (auto& fragment : fragments_) {
+    CHECK_EQ(fragment.flushing.size(), 0);
+    MutexLock lock(&fragment.mu_active);
+    fragment.flushing.swap(fragment.active);
+  }
+  // Now we've swapped out, call the callback repeatedly with each fragment.
+  // This is the slow part - there's a lot of copying and transformation that
+  // happens here.
+  // We keep the mu_flushing_ held so that we can guarantee only one thread is
+  // consumed by this at a time.
+  // Once we've called the callback for each fragment we can clear it, so that
+  // when we next swap it with the active fragment it will be empty.
+  // This also retains the memory, so if we're serializing with a regular
+  // cadence we'll tend to stabilize memory usage for latent_see relatively
+  // quickly.
+  for (auto& fragment : fragments_) {
+    callback(fragment.flushing);
+    fragment.flushing.clear();
   }
-  if (!start_time.has_value()) return "[]";
+  mu_flushing_.Unlock();
+}
+
+absl::optional<std::string> Log::TryGenerateJson() {
+  using Nanos = std::chrono::duration<unsigned long long, std::nano>;
   std::string json = "[\n";
   bool first = true;
-  for (const auto& event : events) {
-    absl::string_view phase;
-    bool has_id;
-    switch (event.event.type) {
-      case EventType::kBegin:
-        phase = "B";
-        has_id = false;
-        break;
-      case EventType::kEnd:
-        phase = "E";
-        has_id = false;
-        break;
-      case EventType::kFlowStart:
-        phase = "s";
-        has_id = true;
-        break;
-      case EventType::kFlowEnd:
-        phase = "f";
-        has_id = true;
-        break;
-      case EventType::kMark:
-        phase = "i";
-        has_id = false;
-        break;
-    }
-    if (!first) absl::StrAppend(&json, ",\n");
-    first = false;
-    if (event.event.metadata->name[0] != '"') {
-      absl::StrAppend(&json, "{\"name\": \"", event.event.metadata->name,
-                      "\", \"ph\": \"", phase, "\", \"ts\": ",
-                      std::chrono::duration<unsigned long long, std::nano>(
-                          event.event.timestamp - *start_time)
-                          .count(),
-                      ", \"pid\": 0, \"tid\": ", event.thread_id);
-    } else {
-      absl::StrAppend(&json, "{\"name\": ", event.event.metadata->name,
-                      ", \"ph\": \"", phase, "\", \"ts\": ",
-                      std::chrono::duration<unsigned long long, std::nano>(
-                          event.event.timestamp - *start_time)
-                          .count(),
-                      ", \"pid\": 0, \"tid\": ", event.thread_id);
-    }
+  int callbacks = 0;
+  TryPullEventsAndFlush([&](absl::Span<const RecordedEvent> events) {
+    ++callbacks;
+    for (const auto& event : events) {
+      absl::string_view phase;
+      bool has_id;
+      switch (event.event.type) {
+        case EventType::kBegin:
+          phase = "B";
+          has_id = false;
+          break;
+        case EventType::kEnd:
+          phase = "E";
+          has_id = false;
+          break;
+        case EventType::kFlowStart:
+          phase = "s";
+          has_id = true;
+          break;
+        case EventType::kFlowEnd:
+          phase = "f";
+          has_id = true;
+          break;
+        case EventType::kMark:
+          phase = "i";
+          has_id = false;
+          break;
+      }
+      if (!first) {
+        absl::StrAppend(&json, ",\n");
+      }
+      first = false;
+      if (event.event.metadata->name[0] != '"') {
+        absl::StrAppend(
+            &json, "{\"name\": \"", event.event.metadata->name,
+            "\", \"ph\": \"", phase, "\", \"ts\": ",
+            Nanos(event.event.timestamp - start_time).count() / 1000.0,
+            ", \"pid\": 0, \"tid\": ", event.thread_id);
+      } else {
+        absl::StrAppend(
+            &json, "{\"name\": ", event.event.metadata->name, ", \"ph\": \"",
+            phase, "\", \"ts\": ",
+            Nanos(event.event.timestamp - start_time).count() / 1000.0,
+            ", \"pid\": 0, \"tid\": ", event.thread_id);
+      }
 
-    if (has_id) {
-      absl::StrAppend(&json, ", \"id\": ", event.event.id);
-    }
-    if (event.event.type == EventType::kFlowEnd) {
-      absl::StrAppend(&json, ", \"bp\": \"e\"");
+      if (has_id) {
+        absl::StrAppend(&json, ", \"id\": ", event.event.id);
+      }
+      if (event.event.type == EventType::kFlowEnd) {
+        absl::StrAppend(&json, ", \"bp\": \"e\"");
+      }
+      absl::StrAppend(&json, ", \"args\": {\"file\": \"",
+                      event.event.metadata->file,
+                      "\", \"line\": ", event.event.metadata->line,
+                      ", \"batch\": ", event.batch_id, "}}");
     }
-    absl::StrAppend(&json, ", \"args\": {\"file\": \"",
-                    event.event.metadata->file,
-                    "\", \"line\": ", event.event.metadata->line,
-                    ", \"batch\": ", event.batch_id, "}}");
-  }
+  });
+  if (callbacks == 0) return absl::nullopt;
   absl::StrAppend(&json, "\n]");
   return json;
 }
@@ -129,9 +150,9 @@ void Log::FlushBin(Bin* bin) {
   auto& fragment = log.fragments_.this_cpu();
   const auto thread_id = thread_id_;
   {
-    MutexLock lock(&fragment.mu);
+    MutexLock lock(&fragment.mu_active);
     for (auto event : bin->events) {
-      fragment.active->Append(RecordedEvent{thread_id, batch_id, event});
+      fragment.active.push_back(RecordedEvent{thread_id, batch_id, event});
     }
   }
   bin->events.clear();

data/src/core/util/latent_see.h

@@ -32,10 +32,11 @@
 
 #include "absl/base/thread_annotations.h"
 #include "absl/functional/any_invocable.h"
+#include "absl/functional/function_ref.h"
 #include "absl/log/log.h"
 #include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
 #include "src/core/util/per_cpu.h"
-#include "src/core/util/ring_buffer.h"
 #include "src/core/util/sync.h"
 
 #define TAGGED_POINTER_SIZE_BITS 48
@@ -71,9 +72,14 @@ struct Bin {
 
 class Log {
  public:
-  static constexpr int kMaxEventsPerCpu = 50000;
   static constexpr uintptr_t kTagMask = (1ULL << TAGGED_POINTER_SIZE_BITS) - 1;
 
+  struct RecordedEvent {
+    uint64_t thread_id;
+    uint64_t batch_id;
+    Bin::Event event;
+  };
+
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static uintptr_t IncrementTag(
       uintptr_t input) {
     return input + (1UL << TAGGED_POINTER_SIZE_BITS);
@@ -115,14 +121,20 @@ class Log {
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static Log& Get() {
     static Log* log = []() {
       atexit([] {
+        auto json = log->TryGenerateJson();
+        if (!json.has_value()) {
+          LOG(INFO) << "Failed to generate latent_see.json (contention with "
+                       "another writer)";
+          return;
+        }
         if (log->stats_flusher_ != nullptr) {
-          log->stats_flusher_(log->GenerateJson());
+          log->stats_flusher_(*json);
           return;
         }
         LOG(INFO) << "Writing latent_see.json in " << get_current_dir_name();
         FILE* f = fopen("latent_see.json", "w");
         if (f == nullptr) return;
-        fprintf(f, "%s", log->GenerateJson().c_str());
+        fprintf(f, "%s", json->c_str());
         fclose(f);
       });
       return new Log();
@@ -130,7 +142,9 @@ class Log {
     return *log;
   }
 
-  std::string GenerateJson();
+  void TryPullEventsAndFlush(
+      absl::FunctionRef<void(absl::Span<const RecordedEvent>)> callback);
+  absl::optional<std::string> TryGenerateJson();
 
   void OverrideStatsFlusher(
       absl::AnyInvocable<void(absl::string_view)> stats_exporter) {
@@ -142,11 +156,6 @@ class Log {
 
   static void FlushBin(Bin* bin);
 
-  struct RecordedEvent {
-    uint64_t thread_id;
-    uint64_t batch_id;
-    Bin::Event event;
-  };
   std::atomic<uint64_t> next_thread_id_{1};
   std::atomic<uint64_t> next_batch_id_{1};
   static thread_local uint64_t thread_id_;
@@ -154,13 +163,11 @@ class Log {
   static thread_local void* bin_owner_;
   static std::atomic<uintptr_t> free_bins_;
   absl::AnyInvocable<void(absl::string_view)> stats_flusher_ = nullptr;
+  Mutex mu_flushing_;
   struct Fragment {
-    Fragment() : active(&primary) {};
-    Mutex mu;
-    RingBuffer<RecordedEvent, Log::kMaxEventsPerCpu>* active
-        ABSL_GUARDED_BY(mu);
-    RingBuffer<RecordedEvent, Log::kMaxEventsPerCpu> primary;
-    RingBuffer<RecordedEvent, Log::kMaxEventsPerCpu> secondary;
+    Mutex mu_active ABSL_ACQUIRED_AFTER(mu_flushing_);
+    std::vector<RecordedEvent> active ABSL_GUARDED_BY(mu_active);
+    std::vector<RecordedEvent> flushing ABSL_GUARDED_BY(&Log::mu_flushing_);
   };
   PerCpu<Fragment> fragments_{PerCpuOptions()};
 };

data/src/core/util/log.cc

@@ -29,7 +29,7 @@
 #include "absl/log/globals.h"
 #include "absl/strings/match.h"
 #include "absl/strings/str_cat.h"
-#include "src/core/lib/config/config_vars.h"
+#include "src/core/config/config_vars.h"
 #include "src/core/util/crash.h"
 #include "src/core/util/string.h"
 

data/src/core/util/status_helper.cc

@@ -318,7 +318,7 @@ std::string StatusToString(const absl::Status& status) {
 absl::Status AddMessagePrefix(absl::string_view prefix, absl::Status status) {
   absl::Status new_status(status.code(),
                           absl::StrCat(prefix, ": ", status.message()));
-  // TODO(roth): Remove this once we elimiate all status attributes.
+  // TODO(roth): Remove this once we eliminate all status attributes.
   status.ForEachPayload(
       [&](absl::string_view type_url, const absl::Cord& payload) {
         new_status.SetPayload(type_url, payload);

data/src/core/util/string.cc

@@ -183,7 +183,7 @@ int gpr_ltoa(long value, char* output) {
 
   sign = value < 0 ? -1 : 1;
   while (value) {
-    output[i++] = static_cast<char>('0' + sign * (value % 10));
+    output[i++] = static_cast<char>('0' + (sign * (value % 10)));
     value /= 10;
   }
   if (sign < 0) output[i++] = '-';
@@ -204,7 +204,7 @@ int int64_ttoa(int64_t value, char* output) {
 
   sign = value < 0 ? -1 : 1;
   while (value) {
-    output[i++] = static_cast<char>('0' + sign * (value % 10));
+    output[i++] = static_cast<char>('0' + (sign * (value % 10)));
     value /= 10;
   }
   if (sign < 0) output[i++] = '-';

data/src/core/util/table.h

@@ -161,7 +161,7 @@ void DestructIfNotNull(T* p) {
 //  do_these_things({(foo<Ts>(), 1)});
 // will execute foo<T>() for each T in Ts.
 // In this example we also leverage the comma operator to make the resultant
-// type of each statement be a consistant int so that C++ type deduction works
+// type of each statement be a consistent int so that C++ type deduction works
 // as we'd like (note that in the expression (a, 1) in C++, the 'result' of the
 // expression is the value after the right-most ',' -- in this case 1, with a
 // executed as a side effect.

data/src/core/util/time.cc

@@ -120,9 +120,9 @@ gpr_timespec MillisecondsAsTimespec(int64_t millis, gpr_clock_type clock_type) {
 int64_t TimespanToMillisRoundUp(gpr_timespec ts) {
   CHECK(ts.clock_type == GPR_TIMESPAN);
   double x = GPR_MS_PER_SEC * static_cast<double>(ts.tv_sec) +
-             static_cast<double>(ts.tv_nsec) / GPR_NS_PER_MS +
-             static_cast<double>(GPR_NS_PER_SEC - 1) /
-                 static_cast<double>(GPR_NS_PER_SEC);
+             (static_cast<double>(ts.tv_nsec) / GPR_NS_PER_MS) +
+             (static_cast<double>(GPR_NS_PER_SEC - 1) /
+              static_cast<double>(GPR_NS_PER_SEC));
   if (x <= static_cast<double>(std::numeric_limits<int64_t>::min())) {
     return std::numeric_limits<int64_t>::min();
   }
@@ -135,7 +135,7 @@ int64_t TimespanToMillisRoundUp(gpr_timespec ts) {
 int64_t TimespanToMillisRoundDown(gpr_timespec ts) {
   CHECK(ts.clock_type == GPR_TIMESPAN);
   double x = GPR_MS_PER_SEC * static_cast<double>(ts.tv_sec) +
-             static_cast<double>(ts.tv_nsec) / GPR_NS_PER_MS;
+             (static_cast<double>(ts.tv_nsec) / GPR_NS_PER_MS);
   if (x <= static_cast<double>(std::numeric_limits<int64_t>::min())) {
     return std::numeric_limits<int64_t>::min();
   }

data/src/core/util/time.h

@@ -227,11 +227,11 @@ class Duration {
   }
 
   static constexpr Duration MicrosecondsRoundUp(int64_t micros) {
-    return Duration(micros / GPR_US_PER_MS + (micros % GPR_US_PER_MS != 0));
+    return Duration((micros / GPR_US_PER_MS) + (micros % GPR_US_PER_MS != 0));
   }
 
   static constexpr Duration NanosecondsRoundUp(int64_t nanos) {
-    return Duration(nanos / GPR_NS_PER_MS + (nanos % GPR_NS_PER_MS != 0));
+    return Duration((nanos / GPR_NS_PER_MS) + (nanos % GPR_NS_PER_MS != 0));
   }
 
   constexpr bool operator==(Duration other) const {

data/src/core/util/uri.cc

@@ -352,6 +352,16 @@ std::string URI::ToString() const {
     parts.emplace_back("//");
     parts.emplace_back(PercentEncode(authority_, IsAuthorityChar));
   }
+  parts.emplace_back(EncodedPathAndQueryParams());
+  if (!fragment_.empty()) {
+    parts.push_back("#");
+    parts.push_back(PercentEncode(fragment_, IsQueryOrFragmentChar));
+  }
+  return absl::StrJoin(parts, "");
+}
+
+std::string URI::EncodedPathAndQueryParams() const {
+  std::vector<std::string> parts;
   if (!path_.empty()) {
     parts.emplace_back(PercentEncode(path_, IsPathChar));
   }
@@ -360,10 +370,6 @@ std::string URI::ToString() const {
     parts.push_back(
         absl::StrJoin(query_parameter_pairs_, "&", QueryParameterFormatter()));
   }
-  if (!fragment_.empty()) {
-    parts.push_back("#");
-    parts.push_back(PercentEncode(fragment_, IsQueryOrFragmentChar));
-  }
   return absl::StrJoin(parts, "");
 }
 

data/src/core/util/uri.h

@@ -76,7 +76,7 @@ class URI {
     return query_parameter_map_;
   }
   // A vector of key:value query parameter pairs, kept in order of appearance
-  // within the URI search string. Repeated keys are represented as separate
+  // within the URI string. Repeated keys are represented as separate
   // key:value elements.
   const std::vector<QueryParam>& query_parameter_pairs() const {
     return query_parameter_pairs_;
@@ -85,6 +85,10 @@ class URI {
 
   std::string ToString() const;
 
+  // Returns the encoded path and query params, such as would be used on
+  // the wire in an HTTP request.
+  std::string EncodedPathAndQueryParams() const;
+
  private:
   URI(std::string scheme, std::string authority, std::string path,
       std::vector<QueryParam> query_parameter_pairs, std::string fragment);

data/src/core/xds/grpc/certificate_provider_store.cc

@@ -23,7 +23,7 @@
 
 #include "absl/log/log.h"
 #include "absl/strings/str_cat.h"
-#include "src/core/lib/config/core_configuration.h"
+#include "src/core/config/core_configuration.h"
 #include "src/core/lib/security/certificate_provider/certificate_provider_registry.h"
 
 namespace grpc_core {

data/src/core/xds/grpc/certificate_provider_store.h

@@ -56,7 +56,7 @@ class CertificateProviderStore final
                       ValidationErrors* errors);
   };
 
-  // Maps plugin instance (opaque) name to plugin defition.
+  // Maps plugin instance (opaque) name to plugin definition.
   typedef std::map<std::string, PluginDefinition> PluginDefinitionMap;
 
   explicit CertificateProviderStore(PluginDefinitionMap plugin_config_map)

data/src/core/xds/grpc/file_watcher_certificate_provider_factory.cc

@@ -29,7 +29,7 @@
 #include "absl/log/log.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
-#include "src/core/lib/config/core_configuration.h"
+#include "src/core/config/core_configuration.h"
 #include "src/core/lib/security/credentials/tls/grpc_tls_certificate_provider.h"
 
 namespace grpc_core {

data/src/core/xds/grpc/xds_cluster_parser.cc

@@ -45,7 +45,7 @@
 #include "google/protobuf/duration.upb.h"
 #include "google/protobuf/struct.upb.h"
 #include "google/protobuf/wrappers.upb.h"
-#include "src/core/lib/config/core_configuration.h"
+#include "src/core/config/core_configuration.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/load_balancing/lb_policy_registry.h"
 #include "src/core/util/env.h"

data/src/core/xds/grpc/xds_http_gcp_authn_filter.cc

@@ -69,9 +69,9 @@ Json::Object ValidateFilterConfig(
           envoy_extensions_filters_http_gcp_authn_v3_TokenCacheConfig_cache_size(
               cache_config))
           .value_or(10);
-  if (cache_size == 0 || cache_size >= INT64_MAX) {
+  if (cache_size == 0) {
     ValidationErrors::ScopedField field(errors, ".cache_config.cache_size");
-    errors->AddError("must be in the range (0, INT64_MAX)");
+    errors->AddError("must be greater than 0");
   }
   config["cache_size"] = Json::FromNumber(cache_size);
   return config;

data/src/core/xds/grpc/xds_lb_policy_registry.cc

@@ -33,7 +33,7 @@
 #include "envoy/extensions/load_balancing_policies/ring_hash/v3/ring_hash.upb.h"
 #include "envoy/extensions/load_balancing_policies/wrr_locality/v3/wrr_locality.upb.h"
 #include "google/protobuf/wrappers.upb.h"
-#include "src/core/lib/config/core_configuration.h"
+#include "src/core/config/core_configuration.h"
 #include "src/core/load_balancing/lb_policy_registry.h"
 #include "src/core/util/time.h"
 #include "src/core/util/validation_errors.h"

data/src/core/xds/grpc/xds_lb_policy_registry.h

@@ -30,7 +30,7 @@
 
 namespace grpc_core {
 
-// A registry that maintans a set of converters that are able to map xDS
+// A registry that maintains a set of converters that are able to map xDS
 // loadbalancing policy configurations to gRPC's JSON format.
 class XdsLbPolicyRegistry final {
  public:

data/src/core/xds/grpc/xds_route_config.cc

@@ -199,6 +199,7 @@ std::string XdsRouteConfigResource::Route::RouteAction::ToString() const {
   if (max_stream_duration.has_value()) {
     contents.push_back(max_stream_duration->ToString());
   }
+  if (auto_host_rewrite) contents.push_back("auto_host_rewrite=true");
   return absl::StrCat("{", absl::StrJoin(contents, ", "), "}");
 }
 

data/src/core/xds/grpc/xds_route_config_parser.cc

@@ -53,8 +53,8 @@
 #include "google/protobuf/duration.upb.h"
 #include "google/protobuf/wrappers.upb.h"
 #include "re2/re2.h"
+#include "src/core/config/core_configuration.h"
 #include "src/core/lib/channel/status_util.h"
-#include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/load_balancing/lb_policy_registry.h"
 #include "src/core/util/env.h"

data/src/core/xds/grpc/xds_server_grpc.cc

@@ -25,7 +25,7 @@
 
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
-#include "src/core/lib/config/core_configuration.h"
+#include "src/core/config/core_configuration.h"
 #include "src/core/util/json/json_reader.h"
 #include "src/core/util/json/json_writer.h"
 

data/src/core/xds/grpc/xds_transport_grpc.cc

@@ -35,10 +35,10 @@
 #include "absl/log/check.h"
 #include "absl/strings/str_cat.h"
 #include "src/core/client_channel/client_channel_filter.h"
+#include "src/core/config/core_configuration.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack.h"
-#include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/event_engine/default_event_engine.h"
 #include "src/core/lib/iomgr/closure.h"

data/src/ruby/ext/grpc/rb_grpc.h

@@ -53,7 +53,7 @@ extern VALUE sym_metadata;
 
 /* GRPC_RB_MEMSIZE_UNAVAILABLE is used in rb_data_type_t to indicate that the
  * number of bytes used by the wrapped struct is not available. */
-#define GRPC_RB_MEMSIZE_UNAVAILABLE (size_t(*)(const void*))(NULL)
+#define GRPC_RB_MEMSIZE_UNAVAILABLE (size_t (*)(const void*))(NULL)
 
 /* A ruby object alloc func that fails by raising an exception. */
 VALUE grpc_rb_cannot_alloc(VALUE cls);

data/src/ruby/lib/grpc/version.rb

@@ -14,5 +14,5 @@
 
 # GRPC contains the General RPC module.
 module GRPC
-  VERSION = '1.68.1'
+  VERSION = '1.69.0.pre1'
 end