grpc 1.39.0 → 1.41.0

data/src/core/lib/transport/metadata.h

@@ -21,14 +21,14 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/impl/codegen/log.h>
+#include <atomic>
 
 #include <grpc/grpc.h>
+#include <grpc/impl/codegen/log.h>
 #include <grpc/slice.h>
 
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gpr/useful.h"
-#include "src/core/lib/gprpp/atomic.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/slice/slice_utils.h"
 
@@ -203,8 +203,8 @@ typedef void (*destroy_user_data_func)(void* data);
 
 struct UserData {
   Mutex mu_user_data;
-  grpc_core::Atomic<destroy_user_data_func> destroy_user_data;
-  grpc_core::Atomic<void*> data;
+  std::atomic<destroy_user_data_func> destroy_user_data{nullptr};
+  std::atomic<void*> data{nullptr};
 };
 
 class StaticMetadata {
@@ -241,7 +241,7 @@ class RefcountedMdBase {
 #ifndef NDEBUG
   void Ref(const char* file, int line) {
     grpc_mdelem_trace_ref(this, key_, value_, RefValue(), file, line);
-    const intptr_t prior = refcnt_.FetchAdd(1, MemoryOrder::RELAXED);
+    const intptr_t prior = refcnt_.fetch_add(1, std::memory_order_relaxed);
     GPR_ASSERT(prior > 0);
   }
   bool Unref(const char* file, int line) {
@@ -253,10 +253,10 @@ class RefcountedMdBase {
     /* we can assume the ref count is >= 1 as the application is calling
        this function - meaning that no adjustment to mdtab_free is necessary,
        simplifying the logic here to be just an atomic increment */
-    refcnt_.FetchAdd(1, MemoryOrder::RELAXED);
+    refcnt_.fetch_add(1, std::memory_order_relaxed);
   }
   bool Unref() {
-    const intptr_t prior = refcnt_.FetchSub(1, MemoryOrder::ACQ_REL);
+    const intptr_t prior = refcnt_.fetch_sub(1, std::memory_order_acq_rel);
     GPR_DEBUG_ASSERT(prior > 0);
     return prior == 1;
   }
@@ -266,15 +266,17 @@ class RefcountedMdBase {
   void TraceAtStart(const char* tag);
 #endif
 
-  intptr_t RefValue() { return refcnt_.Load(MemoryOrder::RELAXED); }
-  bool AllRefsDropped() { return refcnt_.Load(MemoryOrder::ACQUIRE) == 0; }
-  bool FirstRef() { return refcnt_.FetchAdd(1, MemoryOrder::RELAXED) == 0; }
+  intptr_t RefValue() { return refcnt_.load(std::memory_order_relaxed); }
+  bool AllRefsDropped() { return refcnt_.load(std::memory_order_acquire) == 0; }
+  bool FirstRef() {
+    return refcnt_.fetch_add(1, std::memory_order_relaxed) == 0;
+  }
 
  private:
   /* must be byte compatible with grpc_mdelem_data */
   grpc_slice key_;
   grpc_slice value_;
-  grpc_core::Atomic<intptr_t> refcnt_;
+  std::atomic<intptr_t> refcnt_{0};
   uint32_t hash_ = 0;
 };
 

data/src/core/lib/transport/metadata_batch.cc

@@ -401,9 +401,20 @@ void grpc_metadata_batch_copy(grpc_metadata_batch* src,
   size_t i = 0;
   for (grpc_linked_mdelem* elem = src->list.head; elem != nullptr;
        elem = elem->next) {
+    // If the mdelem is not external, take a ref.
+    // Otherwise, create a new copy, holding its own refs to the
+    // underlying slices.
+    grpc_mdelem md;
+    if (GRPC_MDELEM_STORAGE(elem->md) != GRPC_MDELEM_STORAGE_EXTERNAL) {
+      md = GRPC_MDELEM_REF(elem->md);
+    } else {
+      md = grpc_mdelem_from_slices(
+          grpc_slice_ref_internal(GRPC_MDKEY(elem->md)),
+          grpc_slice_ref_internal(GRPC_MDVALUE(elem->md)));
+    }
     // Error unused in non-debug builds.
-    grpc_error_handle GRPC_UNUSED error = grpc_metadata_batch_add_tail(
-        dst, &storage[i++], GRPC_MDELEM_REF(elem->md));
+    grpc_error_handle GRPC_UNUSED error =
+        grpc_metadata_batch_add_tail(dst, &storage[i++], md);
     // The only way that grpc_metadata_batch_add_tail() can fail is if
     // there's a duplicate entry for a callout.  However, that can't be
     // the case here, because we would not have been allowed to create

data/src/core/lib/transport/metadata_batch.h

@@ -57,6 +57,14 @@ typedef struct grpc_metadata_batch {
       or GRPC_MILLIS_INF_FUTURE if this batch does not need to send a
       grpc-timeout */
   grpc_millis deadline;
+
+  template <typename Encoder>
+  void Encode(Encoder* encoder) const {
+    for (auto* l = list.head; l; l = l->next) {
+      encoder->Encode(l->md);
+    }
+    if (deadline != GRPC_MILLIS_INF_FUTURE) encoder->EncodeDeadline(deadline);
+  }
 } grpc_metadata_batch;
 
 void grpc_metadata_batch_init(grpc_metadata_batch* batch);
@@ -196,6 +204,13 @@ void grpc_metadata_batch_assert_ok(grpc_metadata_batch* batch);
 
 /// Copies \a src to \a dst.  \a storage must point to an array of
 /// \a grpc_linked_mdelem structs of at least the same size as \a src.
+///
+/// For each mdelem in \a src, if the mdelem is of storage types
+/// GRPC_MDELEM_STORAGE_INTERNED or GRPC_MDELEM_STORAGE_ALLOCATED,
+/// refs the original mdelem for the copy.  Otherwise, makes a new
+/// mdelem that will hold its own refs to the key and value slices.
+///
+/// Currently used only in the retry code.
 void grpc_metadata_batch_copy(grpc_metadata_batch* src,
                               grpc_metadata_batch* dst,
                               grpc_linked_mdelem* storage);

data/src/core/lib/transport/transport_op_string.cc

@@ -18,8 +18,6 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/channel/channel_stack.h"
-
 #include <inttypes.h>
 #include <stdarg.h>
 #include <stdio.h>
@@ -33,6 +31,8 @@
 
 #include <grpc/support/alloc.h>
 #include <grpc/support/string_util.h>
+
+#include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/slice/slice_string_helpers.h"
 #include "src/core/lib/transport/connectivity_state.h"

data/src/core/plugin_registry/grpc_plugin_registry.cc

@@ -20,6 +20,8 @@
 
 #include <grpc/grpc.h>
 
+#include "src/core/lib/config/core_configuration.h"
+
 void grpc_http_filters_init(void);
 void grpc_http_filters_shutdown(void);
 void grpc_chttp2_plugin_init(void);
@@ -160,3 +162,15 @@ void grpc_register_built_in_plugins(void) {
                        grpc_core::GoogleCloud2ProdResolverShutdown);
 #endif
 }
+
+namespace grpc_core {
+
+extern void BuildClientChannelConfiguration(CoreConfiguration::Builder* builder);
+extern void SecurityRegisterHandshakerFactories(CoreConfiguration::Builder* builder);
+
+void BuildCoreConfiguration(CoreConfiguration::Builder* builder) {
+  BuildClientChannelConfiguration(builder);
+  SecurityRegisterHandshakerFactories(builder);
+}
+
+}  // namespace grpc_core

data/src/core/tsi/alts/crypt/aes_gcm.cc

@@ -18,17 +18,18 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/tsi/alts/crypt/gsec.h"
+#include <string.h>
 
 #include <openssl/bio.h>
 #include <openssl/buffer.h>
 #include <openssl/err.h>
 #include <openssl/evp.h>
 #include <openssl/hmac.h>
-#include <string.h>
 
 #include <grpc/support/alloc.h>
 
+#include "src/core/tsi/alts/crypt/gsec.h"
+
 constexpr size_t kKdfKeyLen = 32;
 constexpr size_t kKdfCounterLen = 6;
 constexpr size_t kKdfCounterOffset = 2;

data/src/core/tsi/alts/crypt/gsec.h

@@ -21,16 +21,15 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/event_engine/port.h>
-
 #include <assert.h>
 #include <stdint.h>
 #include <stdlib.h>
 
+#include <grpc/event_engine/port.h>
 #include <grpc/grpc.h>
 
 #ifndef _STRUCT_IOVEC
-#ifndef GRPC_EVENT_ENGINE_POSIX
+#if !defined(GRPC_EVENT_ENGINE_POSIX)
 struct iovec {
   void* iov_base;
   size_t iov_len;

data/src/core/tsi/alts/handshaker/alts_handshaker_client.cc

@@ -18,10 +18,10 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <list>
-
 #include "src/core/tsi/alts/handshaker/alts_handshaker_client.h"
 
+#include <list>
+
 #include "upb/upb.hpp"
 
 #include <grpc/byte_buffer.h>

data/src/core/tsi/alts/handshaker/alts_handshaker_client.h

@@ -25,11 +25,10 @@
 #include <grpc/byte_buffer_reader.h>
 #include <grpc/grpc.h>
 
-#include "src/core/tsi/alts/handshaker/alts_tsi_handshaker.h"
-#include "src/core/tsi/transport_security_interface.h"
-
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/pollset_set.h"
+#include "src/core/tsi/alts/handshaker/alts_tsi_handshaker.h"
+#include "src/core/tsi/transport_security_interface.h"
 
 #define ALTS_SERVICE_METHOD "/grpc.gcp.HandshakerService/DoHandshake"
 #define ALTS_APPLICATION_PROTOCOL "grpc"

data/src/core/tsi/alts/zero_copy_frame_protector/alts_grpc_integrity_only_record_protocol.cc

@@ -20,11 +20,11 @@
 
 #include "src/core/tsi/alts/zero_copy_frame_protector/alts_grpc_integrity_only_record_protocol.h"
 
+#include <string.h>
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
-#include <string.h>
-
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/tsi/alts/zero_copy_frame_protector/alts_grpc_record_protocol_common.h"
 #include "src/core/tsi/alts/zero_copy_frame_protector/alts_iovec_record_protocol.h"

data/src/core/tsi/ssl/session_cache/ssl_session_cache.cc

@@ -18,14 +18,15 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/gprpp/sync.h"
-#include "src/core/lib/slice/slice_internal.h"
-#include "src/core/tsi/ssl/session_cache/ssl_session.h"
 #include "src/core/tsi/ssl/session_cache/ssl_session_cache.h"
 
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 
+#include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/slice/slice_internal.h"
+#include "src/core/tsi/ssl/session_cache/ssl_session.h"
+
 namespace tsi {
 
 static void cache_key_avl_destroy(void* /*key*/, void* /*unused*/) {}

data/src/core/tsi/ssl/session_cache/ssl_session_openssl.cc

@@ -18,10 +18,10 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/tsi/ssl/session_cache/ssl_session.h"
-
 #include <grpc/support/log.h>
 
+#include "src/core/tsi/ssl/session_cache/ssl_session.h"
+
 #ifndef OPENSSL_IS_BORINGSSL
 
 // OpenSSL invalidates SSL_SESSION on SSL destruction making it pointless

data/src/core/tsi/ssl_transport_security.cc

@@ -35,6 +35,9 @@
 
 #include <string>
 
+#include "absl/strings/match.h"
+#include "absl/strings/string_view.h"
+
 #include <grpc/grpc_security.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
@@ -42,9 +45,6 @@
 #include <grpc/support/sync.h>
 #include <grpc/support/thd_id.h>
 
-#include "absl/strings/match.h"
-#include "absl/strings/string_view.h"
-
 extern "C" {
 #include <openssl/bio.h>
 #include <openssl/crypto.h> /* For OPENSSL_free */
@@ -503,10 +503,10 @@ static void log_ssl_error_stack(void) {
 /* Performs an SSL_read and handle errors. */
 static tsi_result do_ssl_read(SSL* ssl, unsigned char* unprotected_bytes,
                               size_t* unprotected_bytes_size) {
-  int read_from_ssl;
   GPR_ASSERT(*unprotected_bytes_size <= INT_MAX);
-  read_from_ssl = SSL_read(ssl, unprotected_bytes,
-                           static_cast<int>(*unprotected_bytes_size));
+  ERR_clear_error();
+  int read_from_ssl = SSL_read(ssl, unprotected_bytes,
+                               static_cast<int>(*unprotected_bytes_size));
   if (read_from_ssl <= 0) {
     read_from_ssl = SSL_get_error(ssl, read_from_ssl);
     switch (read_from_ssl) {
@@ -536,10 +536,10 @@ static tsi_result do_ssl_read(SSL* ssl, unsigned char* unprotected_bytes,
 /* Performs an SSL_write and handle errors. */
 static tsi_result do_ssl_write(SSL* ssl, unsigned char* unprotected_bytes,
                                size_t unprotected_bytes_size) {
-  int ssl_write_result;
   GPR_ASSERT(unprotected_bytes_size <= INT_MAX);
-  ssl_write_result = SSL_write(ssl, unprotected_bytes,
-                               static_cast<int>(unprotected_bytes_size));
+  ERR_clear_error();
+  int ssl_write_result = SSL_write(ssl, unprotected_bytes,
+                                   static_cast<int>(unprotected_bytes_size));
   if (ssl_write_result < 0) {
     ssl_write_result = SSL_get_error(ssl, ssl_write_result);
     if (ssl_write_result == SSL_ERROR_WANT_READ) {
@@ -1449,6 +1449,7 @@ static tsi_result ssl_handshaker_process_bytes_from_peer(
     impl->result = TSI_OK;
     return impl->result;
   } else {
+    ERR_clear_error();
     /* Get ready to get some bytes from SSL. */
     int ssl_result = SSL_do_handshake(impl->ssl);
     ssl_result = SSL_get_error(impl->ssl, ssl_result);
@@ -1645,6 +1646,7 @@ static tsi_result create_tsi_ssl_handshaker(SSL_CTX* ctx, int is_client,
       tsi_ssl_handshaker_resume_session(ssl,
                                         client_factory->session_cache.get());
     }
+    ERR_clear_error();
     ssl_result = SSL_do_handshake(ssl);
     ssl_result = SSL_get_error(ssl, ssl_result);
     if (ssl_result != SSL_ERROR_WANT_READ) {

data/src/core/tsi/ssl_transport_security.h

@@ -21,8 +21,10 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/grpc_security_constants.h>
 #include "absl/strings/string_view.h"
+
+#include <grpc/grpc_security_constants.h>
+
 #include "src/core/tsi/transport_security_interface.h"
 
 extern "C" {

data/src/core/tsi/transport_security.cc

@@ -20,12 +20,12 @@
 
 #include "src/core/tsi/transport_security.h"
 
-#include <grpc/support/alloc.h>
-#include <grpc/support/string_util.h>
-
 #include <stdlib.h>
 #include <string.h>
 
+#include <grpc/support/alloc.h>
+#include <grpc/support/string_util.h>
+
 /* --- Tracing. --- */
 
 grpc_core::TraceFlag tsi_tracing_enabled(false, "tsi");

data/src/core/tsi/transport_security_grpc.h

@@ -22,6 +22,7 @@
 #include <grpc/support/port_platform.h>
 
 #include <grpc/slice_buffer.h>
+
 #include "src/core/tsi/transport_security.h"
 
 /* This method creates a tsi_zero_copy_grpc_protector object. It return TSI_OK

data/src/ruby/ext/grpc/extconf.rb

@@ -57,7 +57,7 @@ end
 
 ENV['CPPFLAGS'] = '-DGPR_BACKWARDS_COMPATIBILITY_MODE'
 ENV['CPPFLAGS'] += ' -DGRPC_XDS_USER_AGENT_NAME_SUFFIX="\"RUBY\"" '
-ENV['CPPFLAGS'] += ' -DGRPC_XDS_USER_AGENT_VERSION_SUFFIX="\"1.39.0\"" '
+ENV['CPPFLAGS'] += ' -DGRPC_XDS_USER_AGENT_VERSION_SUFFIX="\"1.41.0\"" '
 
 output_dir = File.expand_path(RbConfig::CONFIG['topdir'])
 grpc_lib_dir = File.join(output_dir, 'libs', grpc_config)

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

@@ -19,12 +19,13 @@
 #include <ruby/ruby.h>
 
 #include "rb_byte_buffer.h"
+
+#include "rb_grpc.h"
 #include "rb_grpc_imports.generated.h"
 
 #include <grpc/byte_buffer_reader.h>
 #include <grpc/grpc.h>
 #include <grpc/slice.h>
-#include "rb_grpc.h"
 
 grpc_byte_buffer* grpc_rb_s_to_byte_buffer(char* string, size_t length) {
   grpc_slice slice = grpc_slice_from_copied_buffer(string, length);

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

@@ -19,6 +19,11 @@
 #include <ruby/ruby.h>
 
 #include "rb_call.h"
+
+#include "rb_byte_buffer.h"
+#include "rb_call_credentials.h"
+#include "rb_completion_queue.h"
+#include "rb_grpc.h"
 #include "rb_grpc_imports.generated.h"
 
 #include <grpc/grpc.h>
@@ -26,11 +31,6 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
-#include "rb_byte_buffer.h"
-#include "rb_call_credentials.h"
-#include "rb_completion_queue.h"
-#include "rb_grpc.h"
-
 /* grpc_rb_cCall is the Call class whose instances proxy grpc_call. */
 static VALUE grpc_rb_cCall;
 

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

@@ -19,19 +19,19 @@
 #include <ruby/ruby.h>
 
 #include "rb_call_credentials.h"
-#include "rb_grpc_imports.generated.h"
 
 #include <ruby/thread.h>
 
+#include "rb_call.h"
+#include "rb_event_thread.h"
+#include "rb_grpc.h"
+#include "rb_grpc_imports.generated.h"
+
 #include <grpc/grpc.h>
 #include <grpc/grpc_security.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
-#include "rb_call.h"
-#include "rb_event_thread.h"
-#include "rb_grpc.h"
-
 /* grpc_rb_cCallCredentials is the ruby class that proxies
  * grpc_call_credentials */
 static VALUE grpc_rb_cCallCredentials = Qnil;

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

@@ -17,25 +17,27 @@
  */
 
 #include <ruby/ruby.h>
-#include <ruby/thread.h>
 
-#include "rb_byte_buffer.h"
 #include "rb_channel.h"
-#include "rb_grpc_imports.generated.h"
 
-#include <grpc/grpc.h>
-#include <grpc/grpc_security.h>
-#include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
-#include <grpc/support/time.h>
+#include <ruby/thread.h>
+
+#include "rb_byte_buffer.h"
 #include "rb_call.h"
 #include "rb_channel_args.h"
 #include "rb_channel_credentials.h"
 #include "rb_completion_queue.h"
 #include "rb_grpc.h"
+#include "rb_grpc_imports.generated.h"
 #include "rb_server.h"
 #include "rb_xds_channel_credentials.h"
 
+#include <grpc/grpc.h>
+#include <grpc/grpc_security.h>
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/time.h>
+
 /* id_channel is the name of the hidden ivar that preserves a reference to the
  * channel on a call, so that calls are not GCed before their channel.  */
 static ID id_channel;

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

@@ -19,12 +19,12 @@
 #include <ruby/ruby.h>
 
 #include "rb_channel_args.h"
+
+#include "rb_grpc.h"
 #include "rb_grpc_imports.generated.h"
 
 #include <grpc/grpc.h>
 
-#include "rb_grpc.h"
-
 static rb_data_type_t grpc_rb_channel_args_data_type = {
     "grpc_channel_args",
     {GRPC_RB_GC_NOT_MARKED,

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

@@ -18,9 +18,12 @@
 
 #include <ruby/ruby.h>
 
+#include "rb_channel_credentials.h"
+
 #include <string.h>
 
-#include "rb_channel_credentials.h"
+#include "rb_call_credentials.h"
+#include "rb_grpc.h"
 #include "rb_grpc_imports.generated.h"
 
 #include <grpc/grpc.h>
@@ -28,9 +31,6 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
-#include "rb_call_credentials.h"
-#include "rb_grpc.h"
-
 /* grpc_rb_cChannelCredentials is the ruby class that proxies
    grpc_channel_credentials. */
 static VALUE grpc_rb_cChannelCredentials = Qnil;

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

@@ -20,6 +20,7 @@
 #define GRPC_RB_CREDENTIALS_H_
 
 #include <ruby/ruby.h>
+
 #include <stdbool.h>
 
 #include <grpc/grpc_security.h>

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

@@ -19,14 +19,15 @@
 #include <ruby/ruby.h>
 
 #include "rb_completion_queue.h"
-#include "rb_grpc_imports.generated.h"
 
 #include <ruby/thread.h>
 
+#include "rb_grpc.h"
+#include "rb_grpc_imports.generated.h"
+
 #include <grpc/grpc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/time.h>
-#include "rb_grpc.h"
 
 /* Used to allow grpc_completion_queue_next call to release the GIL */
 typedef struct next_call_stack {

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

@@ -18,8 +18,12 @@
 
 #include <ruby/ruby.h>
 
-#include "rb_byte_buffer.h"
 #include "rb_compression_options.h"
+
+#include <string.h>
+
+#include "rb_byte_buffer.h"
+#include "rb_grpc.h"
 #include "rb_grpc_imports.generated.h"
 
 #include <grpc/compression.h>
@@ -29,9 +33,6 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
-#include <string.h>
-
-#include "rb_grpc.h"
 
 static VALUE grpc_rb_cCompressionOptions = Qnil;
 

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

@@ -19,17 +19,17 @@
 #include <ruby/ruby.h>
 
 #include "rb_event_thread.h"
-#include "rb_grpc_imports.generated.h"
 
+#include <ruby/thread.h>
 #include <stdbool.h>
 
+#include "rb_grpc.h"
+#include "rb_grpc_imports.generated.h"
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/sync.h>
 #include <grpc/support/time.h>
-#include <ruby/thread.h>
-
-#include "rb_grpc.h"
 
 typedef struct grpc_rb_event {
   // callback will be called with argument while holding the GVL

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

@@ -19,7 +19,6 @@
 #include <ruby/ruby.h>
 
 #include "rb_grpc.h"
-#include "rb_grpc_imports.generated.h"
 
 #include <math.h>
 #include <ruby/vm.h>
@@ -28,21 +27,23 @@
 #include <sys/types.h>
 #include <unistd.h>
 
-#include <grpc/grpc.h>
-#include <grpc/support/log.h>
-#include <grpc/support/time.h>
 #include "rb_call.h"
 #include "rb_call_credentials.h"
 #include "rb_channel.h"
 #include "rb_channel_credentials.h"
 #include "rb_compression_options.h"
 #include "rb_event_thread.h"
+#include "rb_grpc_imports.generated.h"
 #include "rb_loader.h"
 #include "rb_server.h"
 #include "rb_server_credentials.h"
 #include "rb_xds_channel_credentials.h"
 #include "rb_xds_server_credentials.h"
 
+#include <grpc/grpc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/time.h>
+
 static VALUE grpc_rb_cTimeVal = Qnil;
 
 static rb_data_type_t grpc_rb_timespec_data_type = {

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

@@ -20,6 +20,7 @@
 #define GRPC_RB_H_
 
 #include <ruby/ruby.h>
+
 #include <sys/time.h>
 
 #include <grpc/support/time.h>