grpc 1.65.2 → 1.66.0.pre3

data/src/core/xds/xds_client/xds_client_stats.cc

@@ -18,7 +18,8 @@
 
 #include "src/core/xds/xds_client/xds_client_stats.h"
 
-#include <grpc/support/log.h>
+#include "absl/log/log.h"
+
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/debug/trace.h"
@@ -51,20 +52,17 @@ XdsClusterDropStats::XdsClusterDropStats(RefCountedPtr<XdsClient> xds_client,
       cluster_name_(cluster_name),
       eds_service_name_(eds_service_name) {
   if (GRPC_TRACE_FLAG_ENABLED(xds_client)) {
-    gpr_log(GPR_INFO, "[xds_client %p] created drop stats %p for {%s, %s, %s}",
-            xds_client_.get(), this, std::string(lrs_server_).c_str(),
-            std::string(cluster_name_).c_str(),
-            std::string(eds_service_name_).c_str());
+    LOG(INFO) << "[xds_client " << xds_client_.get() << "] created drop stats "
+              << this << " for {" << lrs_server_ << ", " << cluster_name_
+              << ", " << eds_service_name_ << "}";
   }
 }
 
 XdsClusterDropStats::~XdsClusterDropStats() {
   if (GRPC_TRACE_FLAG_ENABLED(xds_client)) {
-    gpr_log(GPR_INFO,
-            "[xds_client %p] destroying drop stats %p for {%s, %s, %s}",
-            xds_client_.get(), this, std::string(lrs_server_).c_str(),
-            std::string(cluster_name_).c_str(),
-            std::string(eds_service_name_).c_str());
+    LOG(INFO) << "[xds_client " << xds_client_.get()
+              << "] destroying drop stats " << this << " for {" << lrs_server_
+              << ", " << cluster_name_ << ", " << eds_service_name_ << "}";
   }
   xds_client_->RemoveClusterDropStats(lrs_server_, cluster_name_,
                                       eds_service_name_, this);
@@ -105,25 +103,24 @@ XdsClusterLocalityStats::XdsClusterLocalityStats(
       eds_service_name_(eds_service_name),
       name_(std::move(name)) {
   if (GRPC_TRACE_FLAG_ENABLED(xds_client)) {
-    gpr_log(
-        GPR_INFO,
-        "[xds_client %p] created locality stats %p for {%s, %s, %s, %s}",
-        xds_client_.get(), this, std::string(lrs_server_).c_str(),
-        std::string(cluster_name_).c_str(),
-        std::string(eds_service_name_).c_str(),
-        name_ == nullptr ? "<none>" : name_->human_readable_string().c_str());
+    LOG(INFO) << "[xds_client " << xds_client_.get()
+              << "] created locality stats " << this << " for {" << lrs_server_
+              << ", " << cluster_name_ << ", " << eds_service_name_ << ", "
+              << (name_ == nullptr ? "<none>"
+                                   : name_->human_readable_string().c_str())
+              << "}";
   }
 }
 
 XdsClusterLocalityStats::~XdsClusterLocalityStats() {
   if (GRPC_TRACE_FLAG_ENABLED(xds_client)) {
-    gpr_log(
-        GPR_INFO,
-        "[xds_client %p] destroying locality stats %p for {%s, %s, %s, %s}",
-        xds_client_.get(), this, std::string(lrs_server_).c_str(),
-        std::string(cluster_name_).c_str(),
-        std::string(eds_service_name_).c_str(),
-        name_ == nullptr ? "<none>" : name_->human_readable_string().c_str());
+    LOG(INFO) << "[xds_client " << xds_client_.get()
+              << "] destroying locality stats " << this << " for {"
+              << lrs_server_ << ", " << cluster_name_ << ", "
+              << eds_service_name_ << ", "
+              << (name_ == nullptr ? "<none>"
+                                   : name_->human_readable_string().c_str())
+              << "}";
   }
   xds_client_->RemoveClusterLocalityStats(lrs_server_, cluster_name_,
                                           eds_service_name_, name_, this);

data/src/ruby/ext/grpc/rb_call.c

@@ -437,7 +437,7 @@ static int grpc_rb_md_ary_fill_hash_cb(VALUE key, VALUE val, VALUE md_ary_obj) {
                  tmp_str);
         return ST_STOP;
       }
-      GPR_ASSERT(md_ary->count < md_ary->capacity);
+      GRPC_RUBY_ASSERT(md_ary->count < md_ary->capacity);
       md_ary->metadata[md_ary->count].key = key_slice;
       md_ary->metadata[md_ary->count].value = value_slice;
       md_ary->count += 1;
@@ -453,7 +453,7 @@ static int grpc_rb_md_ary_fill_hash_cb(VALUE key, VALUE val, VALUE md_ary_obj) {
                tmp_str);
       return ST_STOP;
     }
-    GPR_ASSERT(md_ary->count < md_ary->capacity);
+    GRPC_RUBY_ASSERT(md_ary->count < md_ary->capacity);
     md_ary->metadata[md_ary->count].key = key_slice;
     md_ary->metadata[md_ary->count].value = value_slice;
     md_ary->count += 1;

data/src/ruby/ext/grpc/rb_channel.c

@@ -123,7 +123,7 @@ static void* run_poll_channels_loop_unblocking_func_wrapper(void* arg);
 // Needs to be called under global_connection_polling_mu
 static void grpc_rb_channel_watch_connection_state_op_complete(
     watch_state_op* op, int success) {
-  GPR_ASSERT(!op->op.api_callback_args.called_back);
+  GRPC_RUBY_ASSERT(!op->op.api_callback_args.called_back);
   op->op.api_callback_args.called_back = 1;
   op->op.api_callback_args.success = success;
   // wake up the watch API call that's waiting on this op
@@ -133,7 +133,7 @@ static void grpc_rb_channel_watch_connection_state_op_complete(
 /* Avoids destroying a channel twice. */
 static void grpc_rb_channel_safe_destroy(bg_watched_channel* bg) {
   gpr_mu_lock(&global_connection_polling_mu);
-  GPR_ASSERT(bg_watched_channel_list_lookup(bg));
+  GRPC_RUBY_ASSERT(bg_watched_channel_list_lookup(bg));
   if (!bg->channel_destroyed) {
     grpc_channel_destroy(bg->channel);
     bg->channel_destroyed = 1;
@@ -253,7 +253,7 @@ static VALUE grpc_rb_channel_init(int argc, VALUE* argv, VALUE self) {
     ch = grpc_channel_create(target_chars, creds, &wrapper->args);
   }
 
-  GPR_ASSERT(ch);
+  GRPC_RUBY_ASSERT(ch);
   stack.channel = ch;
   stack.wrapper = wrapper;
   rb_thread_call_without_gvl(
@@ -416,7 +416,7 @@ static void grpc_rb_channel_maybe_recreate_channel_after_fork(
   if (bg->channel_destroyed) {
     // There must be one ref at this point, held by the ruby-level channel
     // object, drop this one here.
-    GPR_ASSERT(bg->refcount == 1);
+    GRPC_RUBY_ASSERT(bg->refcount == 1);
     rb_thread_call_without_gvl(channel_safe_destroy_without_gil, bg, NULL,
                                NULL);
     // re-create C-core channel
@@ -581,8 +581,8 @@ static void bg_watched_channel_list_free_and_remove(
     bg_watched_channel* target) {
   bg_watched_channel* bg = NULL;
 
-  GPR_ASSERT(bg_watched_channel_list_lookup(target));
-  GPR_ASSERT(target->channel_destroyed && target->refcount == 0);
+  GRPC_RUBY_ASSERT(bg_watched_channel_list_lookup(target));
+  GRPC_RUBY_ASSERT(target->channel_destroyed && target->refcount == 0);
   if (bg_watched_channel_list_head == target) {
     bg_watched_channel_list_head = target->next;
     gpr_free(target);
@@ -597,7 +597,7 @@ static void bg_watched_channel_list_free_and_remove(
     }
     bg = bg->next;
   }
-  GPR_ASSERT(0);
+  GRPC_RUBY_ASSERT(0);
 }
 
 /* Initialize a grpc_rb_channel's "protected grpc_channel" and try to push
@@ -621,11 +621,11 @@ static void grpc_rb_channel_try_register_connection_polling(
   grpc_connectivity_state conn_state;
   watch_state_op* op = NULL;
   if (bg->refcount == 0) {
-    GPR_ASSERT(bg->channel_destroyed);
+    GRPC_RUBY_ASSERT(bg->channel_destroyed);
     bg_watched_channel_list_free_and_remove(bg);
     return;
   }
-  GPR_ASSERT(bg->refcount == 1);
+  GRPC_RUBY_ASSERT(bg->refcount == 1);
   if (bg->channel_destroyed || g_abort_channel_polling) {
     return;
   }
@@ -633,7 +633,7 @@ static void grpc_rb_channel_try_register_connection_polling(
   if (conn_state == GRPC_CHANNEL_SHUTDOWN) {
     return;
   }
-  GPR_ASSERT(bg_watched_channel_list_lookup(bg));
+  GRPC_RUBY_ASSERT(bg_watched_channel_list_lookup(bg));
   // prevent bg from being free'd by GC while background thread is watching it
   bg->refcount++;
   op = gpr_zalloc(sizeof(watch_state_op));
@@ -679,7 +679,7 @@ static void* run_poll_channels_loop_no_gil(void* arg) {
         grpc_rb_channel_watch_connection_state_op_complete(
             (watch_state_op*)event.tag, event.success);
       } else {
-        GPR_ASSERT(0);
+        GRPC_RUBY_ASSERT(0);
       }
     }
     gpr_mu_unlock(&global_connection_polling_mu);
@@ -769,9 +769,9 @@ static void do_basic_init() {
  */
 void grpc_rb_channel_polling_thread_start() {
   gpr_once_init(&g_once_init, do_basic_init);
-  GPR_ASSERT(!RTEST(g_channel_polling_thread));
-  GPR_ASSERT(!g_abort_channel_polling);
-  GPR_ASSERT(g_channel_polling_cq == NULL);
+  GRPC_RUBY_ASSERT(!RTEST(g_channel_polling_thread));
+  GRPC_RUBY_ASSERT(!g_abort_channel_polling);
+  GRPC_RUBY_ASSERT(g_channel_polling_cq == NULL);
 
   g_channel_polling_cq = grpc_completion_queue_create_for_next(NULL);
   g_channel_polling_thread = rb_thread_create(run_poll_channels_loop, NULL);

data/src/ruby/ext/grpc/rb_channel_args.c

@@ -160,7 +160,7 @@ void grpc_rb_hash_convert_to_channel_args(VALUE src_hash,
 }
 
 void grpc_rb_channel_args_destroy(grpc_channel_args* args) {
-  GPR_ASSERT(args != NULL);
+  GRPC_RUBY_ASSERT(args != NULL);
   if (args->args == NULL) return;
   for (int i = 0; i < args->num_args; i++) {
     // the key was created with gpr_strdup

data/src/ruby/ext/grpc/rb_compression_options.c

@@ -181,9 +181,9 @@ void grpc_rb_compression_options_algorithm_name_to_value_internal(
     char* name_slice_str = grpc_slice_to_c_string(name_slice);
     char* error_message_str = NULL;
     VALUE error_message_ruby_str = Qnil;
-    GPR_ASSERT(gpr_asprintf(&error_message_str,
-                            "Invalid compression algorithm name: %s",
-                            name_slice_str) != -1);
+    GRPC_RUBY_ASSERT(gpr_asprintf(&error_message_str,
+                                  "Invalid compression algorithm name: %s",
+                                  name_slice_str) != -1);
     gpr_free(name_slice_str);
     error_message_ruby_str =
         rb_str_new(error_message_str, strlen(error_message_str));

data/src/ruby/ext/grpc/rb_event_thread.c

@@ -149,12 +149,12 @@ void grpc_rb_event_queue_thread_start() {
     event_queue.head = event_queue.tail = NULL;
   }
   event_queue.abort = false;
-  GPR_ASSERT(!RTEST(g_event_thread));
+  GRPC_RUBY_ASSERT(!RTEST(g_event_thread));
   g_event_thread = rb_thread_create(grpc_rb_event_thread, NULL);
 }
 
 void grpc_rb_event_queue_thread_stop() {
-  GPR_ASSERT(g_one_time_init_done);
+  GRPC_RUBY_ASSERT(g_one_time_init_done);
   if (!RTEST(g_event_thread)) {
     gpr_log(GPR_ERROR,
             "GRPC_RUBY: call credentials thread stop: thread not running");

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

@@ -248,12 +248,12 @@ static pid_t g_init_pid;
 static long g_init_tid;
 
 static bool grpc_ruby_initial_pid(void) {
-  GPR_ASSERT(g_init_pid != 0);
+  GRPC_RUBY_ASSERT(g_init_pid != 0);
   return g_init_pid == getpid();
 }
 
 static bool grpc_ruby_initial_thread(void) {
-  GPR_ASSERT(g_init_tid != 0);
+  GRPC_RUBY_ASSERT(g_init_tid != 0);
   return sys_gettid() == g_init_tid;
 }
 
@@ -263,8 +263,8 @@ static void grpc_ruby_reset_init_state(void) {
 }
 
 static void grpc_ruby_basic_init(void) {
-  GPR_ASSERT(g_init_pid == 0);
-  GPR_ASSERT(g_init_tid == 0);
+  GRPC_RUBY_ASSERT(g_init_pid == 0);
+  GRPC_RUBY_ASSERT(g_init_tid == 0);
   grpc_ruby_reset_init_state();
   // TODO(apolcyn): ideally, we should share logic with C-core
   // for determining whether or not fork support is enabled, rather

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

@@ -21,6 +21,8 @@
 
 #include <ruby/ruby.h>
 
+#include <stdlib.h>
+
 #include <grpc/support/time.h>
 
 /* grpc_rb_mGrpcCore is the module containing the ruby wrapper GRPC classes. */
@@ -78,4 +80,10 @@ void grpc_rb_fork_unsafe_end();
 
 void grpc_ruby_init();
 
+#define GRPC_RUBY_ASSERT(x)                                       \
+  if (!(x)) {                                                     \
+    fprintf(stderr, "%s:%d assert failed\n", __FILE__, __LINE__); \
+    abort();                                                      \
+  }
+
 #endif /* GRPC_RB_H_ */

data/src/ruby/ext/grpc/rb_grpc_imports.generated.c

@@ -253,14 +253,12 @@ gpr_malloc_aligned_type gpr_malloc_aligned_import;
 gpr_free_aligned_type gpr_free_aligned_import;
 gpr_cpu_num_cores_type gpr_cpu_num_cores_import;
 gpr_cpu_current_cpu_type gpr_cpu_current_cpu_import;
-gpr_log_severity_string_type gpr_log_severity_string_import;
 gpr_log_type gpr_log_import;
 gpr_should_log_type gpr_should_log_import;
 gpr_log_message_type gpr_log_message_import;
 gpr_set_log_verbosity_type gpr_set_log_verbosity_import;
 gpr_log_verbosity_init_type gpr_log_verbosity_init_import;
 gpr_set_log_function_type gpr_set_log_function_import;
-gpr_assertion_failed_type gpr_assertion_failed_import;
 gpr_format_message_type gpr_format_message_import;
 gpr_strdup_type gpr_strdup_import;
 gpr_asprintf_type gpr_asprintf_import;
@@ -543,14 +541,12 @@ void grpc_rb_load_imports(HMODULE library) {
   gpr_free_aligned_import = (gpr_free_aligned_type) GetProcAddress(library, "gpr_free_aligned");
   gpr_cpu_num_cores_import = (gpr_cpu_num_cores_type) GetProcAddress(library, "gpr_cpu_num_cores");
   gpr_cpu_current_cpu_import = (gpr_cpu_current_cpu_type) GetProcAddress(library, "gpr_cpu_current_cpu");
-  gpr_log_severity_string_import = (gpr_log_severity_string_type) GetProcAddress(library, "gpr_log_severity_string");
   gpr_log_import = (gpr_log_type) GetProcAddress(library, "gpr_log");
   gpr_should_log_import = (gpr_should_log_type) GetProcAddress(library, "gpr_should_log");
   gpr_log_message_import = (gpr_log_message_type) GetProcAddress(library, "gpr_log_message");
   gpr_set_log_verbosity_import = (gpr_set_log_verbosity_type) GetProcAddress(library, "gpr_set_log_verbosity");
   gpr_log_verbosity_init_import = (gpr_log_verbosity_init_type) GetProcAddress(library, "gpr_log_verbosity_init");
   gpr_set_log_function_import = (gpr_set_log_function_type) GetProcAddress(library, "gpr_set_log_function");
-  gpr_assertion_failed_import = (gpr_assertion_failed_type) GetProcAddress(library, "gpr_assertion_failed");
   gpr_format_message_import = (gpr_format_message_type) GetProcAddress(library, "gpr_format_message");
   gpr_strdup_import = (gpr_strdup_type) GetProcAddress(library, "gpr_strdup");
   gpr_asprintf_import = (gpr_asprintf_type) GetProcAddress(library, "gpr_asprintf");

data/src/ruby/ext/grpc/rb_grpc_imports.generated.h

@@ -735,9 +735,6 @@ extern gpr_cpu_num_cores_type gpr_cpu_num_cores_import;
 typedef unsigned(*gpr_cpu_current_cpu_type)(void);
 extern gpr_cpu_current_cpu_type gpr_cpu_current_cpu_import;
 #define gpr_cpu_current_cpu gpr_cpu_current_cpu_import
-typedef const char*(*gpr_log_severity_string_type)(gpr_log_severity severity);
-extern gpr_log_severity_string_type gpr_log_severity_string_import;
-#define gpr_log_severity_string gpr_log_severity_string_import
 typedef void(*gpr_log_type)(const char* file, int line, gpr_log_severity severity, const char* format, ...) GPR_PRINT_FORMAT_CHECK(4, 5);
 extern gpr_log_type gpr_log_import;
 #define gpr_log gpr_log_import
@@ -756,9 +753,6 @@ extern gpr_log_verbosity_init_type gpr_log_verbosity_init_import;
 typedef void(*gpr_set_log_function_type)(gpr_log_func deprecated_setting);
 extern gpr_set_log_function_type gpr_set_log_function_import;
 #define gpr_set_log_function gpr_set_log_function_import
-typedef void(*gpr_assertion_failed_type)(const char* filename, int line, const char* message);
-extern gpr_assertion_failed_type gpr_assertion_failed_import;
-#define gpr_assertion_failed gpr_assertion_failed_import
 typedef char*(*gpr_format_message_type)(int messageid);
 extern gpr_format_message_type gpr_format_message_import;
 #define gpr_format_message gpr_format_message_import

data/src/ruby/ext/grpc/rb_server.c

@@ -193,7 +193,7 @@ struct server_request_call_args {
 static void shutdown_server_unblock_func(void* arg) {
   grpc_rb_server* server = (grpc_rb_server*)arg;
   gpr_log(GPR_INFO, "GRPC_RUBY: shutdown_server_unblock_func");
-  GPR_ASSERT(server->wrapped != NULL);
+  GRPC_RUBY_ASSERT(server->wrapped != NULL);
   grpc_event event;
   void* tag = &event;
   grpc_server_shutdown_and_notify(server->wrapped, server->queue, tag);

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

@@ -14,6 +14,19 @@
 
 # GRPC contains the General RPC module.
 module GRPC
+  def self.logger=(logger_obj)
+    # Need a free variable here to keep value of logger_obj for logger closure
+    @logger = logger_obj
+
+    extend(
+      Module.new do
+        def logger
+          @logger
+        end
+      end
+    )
+  end
+
   # DefaultLogger is a module included in GRPC if no other logging is set up for
   # it.  See ../spec/spec_helpers an example of where other logging is added.
   module DefaultLogger

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

@@ -14,5 +14,5 @@
 
 # GRPC contains the General RPC module.
 module GRPC
-  VERSION = '1.65.2'
+  VERSION = '1.66.0.pre3'
 end

data/src/ruby/spec/logconfig_spec.rb

@@ -0,0 +1,30 @@
+# Copyright 2024 gRPC authors.
+#
+# 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.
+
+require 'spec_helper'
+require 'logger'
+
+describe GRPC do
+  describe '.logger=' do
+    it 'sets logger' do
+      noop_logger = GRPC::DefaultLogger::NoopLogger.new
+      GRPC.logger = noop_logger
+      expect(GRPC.logger).to be(noop_logger)
+
+      custom_logger = Logger.new(STDOUT)
+      GRPC.logger = custom_logger
+      expect(GRPC.logger).to be(custom_logger)
+    end
+  end
+end

data/third_party/upb/upb/base/string_view.h

@@ -46,7 +46,7 @@ UPB_INLINE bool upb_StringView_IsEqual(upb_StringView a, upb_StringView b) {
 }
 
 // LINT.ThenChange(
-//  GoogleInternalName0,
+//  GoogleInternalName1,
 //  //depot/google3/third_party/upb/bits/golang/accessor.go:map_go_string,
 //  //depot/google3/third_party/upb/bits/typescript/string_view.ts
 // )

data/third_party/upb/upb/json/decode.c

@@ -1510,6 +1510,7 @@ static bool upb_JsonDecoder_Decode(jsondec* const d, upb_Message* const msg,
 bool upb_JsonDecode(const char* buf, size_t size, upb_Message* msg,
                     const upb_MessageDef* m, const upb_DefPool* symtab,
                     int options, upb_Arena* arena, upb_Status* status) {
+  UPB_ASSERT(!upb_Message_IsFrozen(msg));
   jsondec d;
 
   if (size == 0) return true;

data/third_party/upb/upb/mem/arena.c

@@ -7,6 +7,10 @@
 
 #include "upb/mem/arena.h"
 
+#ifdef UPB_TRACING_ENABLED
+#include <stdatomic.h>
+#endif
+
 #include <stddef.h>
 #include <stdint.h>
 
@@ -117,6 +121,38 @@ static bool _upb_ArenaInternal_HasInitialBlock(upb_ArenaInternal* ai) {
   return ai->block_alloc & 0x1;
 }
 
+#ifdef UPB_TRACING_ENABLED
+static void (*_init_arena_trace_handler)(const upb_Arena*, size_t size) = NULL;
+static void (*_fuse_arena_trace_handler)(const upb_Arena*,
+                                         const upb_Arena*) = NULL;
+static void (*_free_arena_trace_handler)(const upb_Arena*) = NULL;
+
+void upb_Arena_SetTraceHandler(
+    void (*initArenaTraceHandler)(const upb_Arena*, size_t size),
+    void (*fuseArenaTraceHandler)(const upb_Arena*, const upb_Arena*),
+    void (*freeArenaTraceHandler)(const upb_Arena*)) {
+  _init_arena_trace_handler = initArenaTraceHandler;
+  _fuse_arena_trace_handler = fuseArenaTraceHandler;
+  _free_arena_trace_handler = freeArenaTraceHandler;
+}
+
+void upb_Arena_LogInit(const upb_Arena* arena, size_t size) {
+  if (_init_arena_trace_handler) {
+    _init_arena_trace_handler(arena, size);
+  }
+}
+void upb_Arena_LogFuse(const upb_Arena* arena1, const upb_Arena* arena2) {
+  if (_fuse_arena_trace_handler) {
+    _fuse_arena_trace_handler(arena1, arena2);
+  }
+}
+void upb_Arena_LogFree(const upb_Arena* arena) {
+  if (_free_arena_trace_handler) {
+    _free_arena_trace_handler(arena);
+  }
+}
+#endif  // UPB_TRACING_ENABLED
+
 static upb_ArenaRoot _upb_Arena_FindRoot(upb_Arena* a) {
   upb_ArenaInternal* ai = upb_Arena_Internal(a);
   uintptr_t poc = upb_Atomic_Load(&ai->parent_or_count, memory_order_acquire);
@@ -174,6 +210,21 @@ size_t upb_Arena_SpaceAllocated(upb_Arena* arena, size_t* fused_count) {
   return memsize;
 }
 
+bool UPB_PRIVATE(_upb_Arena_Contains)(const upb_Arena* a, void* ptr) {
+  upb_ArenaInternal* ai = upb_Arena_Internal(a);
+  UPB_ASSERT(ai);
+
+  upb_MemBlock* block = upb_Atomic_Load(&ai->blocks, memory_order_relaxed);
+  while (block) {
+    uintptr_t beg = (uintptr_t)block;
+    uintptr_t end = beg + block->size;
+    if ((uintptr_t)ptr >= beg && (uintptr_t)ptr < end) return true;
+    block = upb_Atomic_Load(&block->next, memory_order_relaxed);
+  }
+
+  return false;
+}
+
 uint32_t upb_Arena_DebugRefCount(upb_Arena* a) {
   upb_ArenaInternal* ai = upb_Arena_Internal(a);
   // These loads could probably be relaxed, but given that this is debug-only,
@@ -265,7 +316,13 @@ upb_Arena* upb_Arena_Init(void* mem, size_t n, upb_alloc* alloc) {
   n = UPB_ALIGN_DOWN(n, UPB_ALIGN_OF(upb_ArenaState));
 
   if (UPB_UNLIKELY(n < sizeof(upb_ArenaState))) {
+#ifdef UPB_TRACING_ENABLED
+    upb_Arena* ret = _upb_Arena_InitSlow(alloc);
+    upb_Arena_LogInit(ret, n);
+    return ret;
+#else
     return _upb_Arena_InitSlow(alloc);
+#endif
   }
 
   a = UPB_PTR_AT(mem, n - sizeof(upb_ArenaState), upb_ArenaState);
@@ -278,13 +335,14 @@ upb_Arena* upb_Arena_Init(void* mem, size_t n, upb_alloc* alloc) {
   a->body.block_alloc = _upb_Arena_MakeBlockAlloc(alloc, 1);
   a->head.UPB_PRIVATE(ptr) = mem;
   a->head.UPB_PRIVATE(end) = UPB_PTR_AT(mem, n - sizeof(upb_ArenaState), char);
-
+#ifdef UPB_TRACING_ENABLED
+  upb_Arena_LogInit(&a->head, n);
+#endif
   return &a->head;
 }
 
 static void _upb_Arena_DoFree(upb_ArenaInternal* ai) {
   UPB_ASSERT(_upb_Arena_RefCountFromTagged(ai->parent_or_count) == 1);
-
   while (ai != NULL) {
     // Load first since arena itself is likely from one of its blocks.
     upb_ArenaInternal* next_arena =
@@ -315,6 +373,9 @@ retry:
   // expensive then direct loads.  As an optimization, we only do RMW ops
   // when we need to update things for other threads to see.
   if (poc == _upb_Arena_TaggedFromRefcount(1)) {
+#ifdef UPB_TRACING_ENABLED
+    upb_Arena_LogFree(a);
+#endif
     _upb_Arena_DoFree(ai);
     return;
   }
@@ -434,6 +495,10 @@ static bool _upb_Arena_FixupRefs(upb_ArenaInternal* new_root,
 bool upb_Arena_Fuse(upb_Arena* a1, upb_Arena* a2) {
   if (a1 == a2) return true;  // trivial fuse
 
+#ifdef UPB_TRACING_ENABLED
+  upb_Arena_LogFuse(a1, a2);
+#endif
+
   upb_ArenaInternal* ai1 = upb_Arena_Internal(a1);
   upb_ArenaInternal* ai2 = upb_Arena_Internal(a2);
 

data/third_party/upb/upb/mem/arena.h

@@ -53,23 +53,25 @@ UPB_API_INLINE upb_Arena* upb_Arena_New(void) {
   return upb_Arena_Init(NULL, 0, &upb_alloc_global);
 }
 
-UPB_API_INLINE void* upb_Arena_Malloc(struct upb_Arena* a, size_t size) {
-  return UPB_PRIVATE(_upb_Arena_Malloc)(a, size);
-}
+UPB_API_INLINE void* upb_Arena_Malloc(struct upb_Arena* a, size_t size);
 
 UPB_API_INLINE void* upb_Arena_Realloc(upb_Arena* a, void* ptr, size_t oldsize,
-                                       size_t size) {
-  return UPB_PRIVATE(_upb_Arena_Realloc)(a, ptr, oldsize, size);
-}
+                                       size_t size);
 
 // Shrinks the last alloc from arena.
 // REQUIRES: (ptr, oldsize) was the last malloc/realloc from this arena.
 // We could also add a upb_Arena_TryShrinkLast() which is simply a no-op if
 // this was not the last alloc.
 UPB_API_INLINE void upb_Arena_ShrinkLast(upb_Arena* a, void* ptr,
-                                         size_t oldsize, size_t size) {
-  UPB_PRIVATE(_upb_Arena_ShrinkLast)(a, ptr, oldsize, size);
-}
+                                         size_t oldsize, size_t size);
+
+#ifdef UPB_TRACING_ENABLED
+void upb_Arena_SetTraceHandler(void (*initArenaTraceHandler)(const upb_Arena*,
+                                                             size_t size),
+                               void (*fuseArenaTraceHandler)(const upb_Arena*,
+                                                             const upb_Arena*),
+                               void (*freeArenaTraceHandler)(const upb_Arena*));
+#endif
 
 #ifdef __cplusplus
 } /* extern "C" */

data/third_party/upb/upb/mem/internal/arena.h

@@ -40,12 +40,16 @@ void UPB_PRIVATE(_upb_Arena_SwapIn)(struct upb_Arena* des,
 void UPB_PRIVATE(_upb_Arena_SwapOut)(struct upb_Arena* des,
                                      const struct upb_Arena* src);
 
+// Returns whether |ptr| was allocated directly by |a| (so care must be used
+// with fused arenas).
+UPB_API bool UPB_ONLYBITS(_upb_Arena_Contains)(const struct upb_Arena* a,
+                                               void* ptr);
+
 UPB_INLINE size_t UPB_PRIVATE(_upb_ArenaHas)(const struct upb_Arena* a) {
   return (size_t)(a->UPB_ONLYBITS(end) - a->UPB_ONLYBITS(ptr));
 }
 
-UPB_INLINE void* UPB_PRIVATE(_upb_Arena_Malloc)(struct upb_Arena* a,
-                                                size_t size) {
+UPB_API_INLINE void* upb_Arena_Malloc(struct upb_Arena* a, size_t size) {
   void* UPB_PRIVATE(_upb_Arena_SlowMalloc)(struct upb_Arena * a, size_t size);
 
   size = UPB_ALIGN_MALLOC(size);
@@ -65,8 +69,8 @@ UPB_INLINE void* UPB_PRIVATE(_upb_Arena_Malloc)(struct upb_Arena* a,
   return ret;
 }
 
-UPB_INLINE void* UPB_PRIVATE(_upb_Arena_Realloc)(struct upb_Arena* a, void* ptr,
-                                                 size_t oldsize, size_t size) {
+UPB_API_INLINE void* upb_Arena_Realloc(struct upb_Arena* a, void* ptr,
+                                       size_t oldsize, size_t size) {
   oldsize = UPB_ALIGN_MALLOC(oldsize);
   size = UPB_ALIGN_MALLOC(size);
   bool is_most_recent_alloc =
@@ -82,7 +86,7 @@ UPB_INLINE void* UPB_PRIVATE(_upb_Arena_Realloc)(struct upb_Arena* a, void* ptr,
     return ptr;
   }
 
-  void* ret = UPB_PRIVATE(_upb_Arena_Malloc)(a, size);
+  void* ret = upb_Arena_Malloc(a, size);
 
   if (ret && oldsize > 0) {
     memcpy(ret, ptr, UPB_MIN(oldsize, size));
@@ -91,9 +95,8 @@ UPB_INLINE void* UPB_PRIVATE(_upb_Arena_Realloc)(struct upb_Arena* a, void* ptr,
   return ret;
 }
 
-UPB_INLINE void UPB_PRIVATE(_upb_Arena_ShrinkLast)(struct upb_Arena* a,
-                                                   void* ptr, size_t oldsize,
-                                                   size_t size) {
+UPB_API_INLINE void upb_Arena_ShrinkLast(struct upb_Arena* a, void* ptr,
+                                         size_t oldsize, size_t size) {
   oldsize = UPB_ALIGN_MALLOC(oldsize);
   size = UPB_ALIGN_MALLOC(size);
   // Must be the last alloc.

data/third_party/upb/upb/message/accessors.c

@@ -20,18 +20,19 @@
 // Must be last.
 #include "upb/port/def.inc"
 
-bool upb_Message_SetMapEntry(upb_Map* map, const upb_MiniTable* mini_table,
+bool upb_Message_SetMapEntry(upb_Map* map, const upb_MiniTable* m,
                              const upb_MiniTableField* f,
                              upb_Message* map_entry_message, upb_Arena* arena) {
+  UPB_ASSERT(!upb_Message_IsFrozen(map_entry_message));
+
   // TODO: use a variant of upb_MiniTable_GetSubMessageTable() here.
   const upb_MiniTable* map_entry_mini_table = upb_MiniTableSub_Message(
-      mini_table->UPB_PRIVATE(subs)[f->UPB_PRIVATE(submsg_index)]);
+      m->UPB_PRIVATE(subs)[f->UPB_PRIVATE(submsg_index)]);
   UPB_ASSERT(map_entry_mini_table);
-  UPB_ASSERT(map_entry_mini_table->UPB_PRIVATE(field_count) == 2);
   const upb_MiniTableField* map_entry_key_field =
-      &map_entry_mini_table->UPB_PRIVATE(fields)[0];
+      upb_MiniTable_MapKey(map_entry_mini_table);
   const upb_MiniTableField* map_entry_value_field =
-      &map_entry_mini_table->UPB_PRIVATE(fields)[1];
+      upb_MiniTable_MapValue(map_entry_mini_table);
   // Map key/value cannot have explicit defaults,
   // hence assuming a zero default is valid.
   upb_MessageValue default_val;