grpc 1.28.0.pre2 → 1.31.0.pre1

data/src/core/tsi/ssl_types.h

@@ -29,8 +29,6 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/tsi/grpc_shadow_boringssl.h"
-
 #include <openssl/ssl.h>
 
 #ifdef OPENSSL_IS_BORINGSSL

data/src/core/tsi/transport_security.h

@@ -30,7 +30,7 @@ extern grpc_core::TraceFlag tsi_tracing_enabled;
 
 /* Base for tsi_frame_protector implementations.
    See transport_security_interface.h for documentation. */
-typedef struct {
+struct tsi_frame_protector_vtable {
   tsi_result (*protect)(tsi_frame_protector* self,
                         const unsigned char* unprotected_bytes,
                         size_t* unprotected_bytes_size,
@@ -46,15 +46,14 @@ typedef struct {
                           unsigned char* unprotected_bytes,
                           size_t* unprotected_bytes_size);
   void (*destroy)(tsi_frame_protector* self);
-} tsi_frame_protector_vtable;
-
+};
 struct tsi_frame_protector {
   const tsi_frame_protector_vtable* vtable;
 };
 
 /* Base for tsi_handshaker implementations.
    See transport_security_interface.h for documentation. */
-typedef struct {
+struct tsi_handshaker_vtable {
   tsi_result (*get_bytes_to_send_to_peer)(tsi_handshaker* self,
                                           unsigned char* bytes,
                                           size_t* bytes_size);
@@ -74,8 +73,7 @@ typedef struct {
                      tsi_handshaker_result** handshaker_result,
                      tsi_handshaker_on_next_done_cb cb, void* user_data);
   void (*shutdown)(tsi_handshaker* self);
-} tsi_handshaker_vtable;
-
+};
 struct tsi_handshaker {
   const tsi_handshaker_vtable* vtable;
   bool frame_protector_created;
@@ -91,7 +89,7 @@ struct tsi_handshaker {
    in grpc, where we do need the exec_ctx passed through, but the API still
    needs to compile in other applications, where grpc_exec_ctx is not defined.
 */
-typedef struct {
+struct tsi_handshaker_result_vtable {
   tsi_result (*extract_peer)(const tsi_handshaker_result* self, tsi_peer* peer);
   tsi_result (*create_zero_copy_grpc_protector)(
       const tsi_handshaker_result* self,
@@ -104,8 +102,7 @@ typedef struct {
                                  const unsigned char** bytes,
                                  size_t* bytes_size);
   void (*destroy)(tsi_handshaker_result* self);
-} tsi_handshaker_result_vtable;
-
+};
 struct tsi_handshaker_result {
   const tsi_handshaker_result_vtable* vtable;
 };

data/src/core/tsi/transport_security_grpc.h

@@ -61,7 +61,7 @@ tsi_result tsi_zero_copy_grpc_protector_max_frame_size(
     tsi_zero_copy_grpc_protector* self, size_t* max_frame_size);
 
 /* Base for tsi_zero_copy_grpc_protector implementations.  */
-typedef struct {
+struct tsi_zero_copy_grpc_protector_vtable {
   tsi_result (*protect)(tsi_zero_copy_grpc_protector* self,
                         grpc_slice_buffer* unprotected_slices,
                         grpc_slice_buffer* protected_slices);
@@ -71,8 +71,7 @@ typedef struct {
   void (*destroy)(tsi_zero_copy_grpc_protector* self);
   tsi_result (*max_frame_size)(tsi_zero_copy_grpc_protector* self,
                                size_t* max_frame_size);
-} tsi_zero_copy_grpc_protector_vtable;
-
+};
 struct tsi_zero_copy_grpc_protector {
   const tsi_zero_copy_grpc_protector_vtable* vtable;
 };

data/src/core/tsi/transport_security_interface.h

@@ -44,6 +44,7 @@ typedef enum {
   TSI_OUT_OF_RESOURCES = 12,
   TSI_ASYNC = 13,
   TSI_HANDSHAKE_SHUTDOWN = 14,
+  TSI_CLOSE_NOTIFY = 15,  // Indicates that the connection should be closed.
 } tsi_result;
 
 typedef enum {
@@ -63,6 +64,11 @@ typedef enum {
   TSI_REQUEST_AND_REQUIRE_CLIENT_CERTIFICATE_AND_VERIFY,
 } tsi_client_certificate_request_type;
 
+typedef enum {
+  TSI_TLS1_2,
+  TSI_TLS1_3,
+} tsi_tls_version;
+
 const char* tsi_result_to_string(tsi_result result);
 const char* tsi_security_level_to_string(tsi_security_level security_level);
 
@@ -207,11 +213,10 @@ typedef struct tsi_peer_property {
   } value;
 } tsi_peer_property;
 
-typedef struct {
+struct tsi_peer {
   tsi_peer_property* properties;
   size_t property_count;
-} tsi_peer;
-
+};
 /* Destructs the tsi_peer object. */
 void tsi_peer_destruct(tsi_peer* self);
 

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

@@ -25,7 +25,7 @@ grpc_config = ENV['GRPC_CONFIG'] || 'opt'
 ENV['MACOSX_DEPLOYMENT_TARGET'] = '10.7'
 
 if ENV['AR'].nil? || ENV['AR'].size == 0
-    ENV['AR'] = RbConfig::CONFIG['AR'] + ' rcs'
+    ENV['AR'] = RbConfig::CONFIG['AR']
 end
 if ENV['CC'].nil? || ENV['CC'].size == 0
     ENV['CC'] = RbConfig::CONFIG['CC']
@@ -37,7 +37,10 @@ if ENV['LD'].nil? || ENV['LD'].size == 0
     ENV['LD'] = ENV['CC']
 end
 
-ENV['AR'] = 'libtool -o' if RUBY_PLATFORM =~ /darwin/
+if RUBY_PLATFORM =~ /darwin/
+  ENV['AR'] = 'libtool'
+  ENV['ARFLAGS'] = '-o'
+ end
 
 ENV['EMBED_OPENSSL'] = 'true'
 ENV['EMBED_ZLIB'] = 'true'

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

@@ -48,7 +48,7 @@ static VALUE grpc_rb_sBatchResult;
 
 /* grpc_rb_cMdAry is the MetadataArray class whose instances proxy
  * grpc_metadata_array. */
-static VALUE grpc_rb_cMdAry;
+VALUE grpc_rb_cMdAry;
 
 /* id_credentials is the name of the hidden ivar that preserves the value
  * of the credentials added to the call */
@@ -103,7 +103,7 @@ static void grpc_rb_call_destroy(void* p) {
   xfree(p);
 }
 
-static const rb_data_type_t grpc_rb_md_ary_data_type = {
+const rb_data_type_t grpc_rb_md_ary_data_type = {
     "grpc_metadata_array",
     {GRPC_RB_GC_NOT_MARKED,
      GRPC_RB_GC_DONT_FREE,
@@ -489,6 +489,7 @@ static int grpc_rb_md_ary_capacity_hash_cb(VALUE key, VALUE val,
 
 /* grpc_rb_md_ary_convert converts a ruby metadata hash into
    a grpc_metadata_array.
+   Note that this function may throw exceptions.
 */
 void grpc_rb_md_ary_convert(VALUE md_ary_hash, grpc_metadata_array* md_ary) {
   VALUE md_ary_obj = Qnil;
@@ -620,6 +621,7 @@ typedef struct run_batch_stack {
   int recv_cancelled;
   grpc_status_code recv_status;
   grpc_slice recv_status_details;
+  const char* recv_status_debug_error_string;
   unsigned write_flag;
   grpc_slice send_status_details;
 } run_batch_stack;
@@ -729,6 +731,8 @@ static void grpc_run_batch_stack_fill_ops(run_batch_stack* st, VALUE ops_hash) {
             &st->recv_status;
         st->ops[st->op_num].data.recv_status_on_client.status_details =
             &st->recv_status_details;
+        st->ops[st->op_num].data.recv_status_on_client.error_string =
+            &st->recv_status_debug_error_string;
         break;
       case GRPC_OP_RECV_CLOSE_ON_SERVER:
         st->ops[st->op_num].data.recv_close_on_server.cancelled =
@@ -780,7 +784,12 @@ static VALUE grpc_run_batch_stack_build_result(run_batch_stack* st) {
                 (GRPC_SLICE_START_PTR(st->recv_status_details) == NULL
                      ? Qnil
                      : grpc_rb_slice_to_ruby_string(st->recv_status_details)),
-                grpc_rb_md_ary_to_h(&st->recv_trailing_metadata), NULL));
+                grpc_rb_md_ary_to_h(&st->recv_trailing_metadata),
+                st->recv_status_debug_error_string == NULL
+                    ? Qnil
+                    : rb_str_new_cstr(st->recv_status_debug_error_string),
+                NULL));
+        gpr_free((void*)st->recv_status_debug_error_string);
         break;
       case GRPC_OP_RECV_CLOSE_ON_SERVER:
         rb_struct_aset(result, sym_send_close, Qtrue);

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

@@ -23,6 +23,10 @@
 
 #include <grpc/grpc.h>
 
+extern const rb_data_type_t grpc_rb_md_ary_data_type;
+
+extern VALUE grpc_rb_cMdAry;
+
 /* Gets the wrapped call from a VALUE. */
 grpc_call* grpc_rb_get_wrapped_call(VALUE v);
 

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

@@ -54,10 +54,41 @@ typedef struct callback_params {
   grpc_credentials_plugin_metadata_cb callback;
 } callback_params;
 
-static VALUE grpc_rb_call_credentials_callback(VALUE callback_args) {
+static VALUE grpc_rb_call_credentials_callback(VALUE args) {
   VALUE result = rb_hash_new();
-  VALUE metadata = rb_funcall(rb_ary_entry(callback_args, 0), rb_intern("call"),
-                              1, rb_ary_entry(callback_args, 1));
+  VALUE callback_func = rb_ary_entry(args, 0);
+  VALUE callback_args = rb_ary_entry(args, 1);
+  VALUE md_ary_obj = rb_ary_entry(args, 2);
+  if (gpr_should_log(GPR_LOG_SEVERITY_DEBUG)) {
+    VALUE callback_func_str = rb_funcall(callback_func, rb_intern("to_s"), 0);
+    VALUE callback_args_str = rb_funcall(callback_args, rb_intern("to_s"), 0);
+    VALUE callback_source_info =
+        rb_funcall(callback_func, rb_intern("source_location"), 0);
+    if (callback_source_info != Qnil) {
+      VALUE source_filename = rb_ary_entry(callback_source_info, 0);
+      VALUE source_line_number = rb_funcall(
+          rb_ary_entry(callback_source_info, 1), rb_intern("to_s"), 0);
+      gpr_log(GPR_DEBUG,
+              "GRPC_RUBY: grpc_rb_call_credentials invoking user callback:|%s| "
+              "source_filename:%s line_number:%s with arguments:|%s|",
+              StringValueCStr(callback_func_str),
+              StringValueCStr(source_filename),
+              StringValueCStr(source_line_number),
+              StringValueCStr(callback_args_str));
+    } else {
+      gpr_log(GPR_DEBUG,
+              "GRPC_RUBY: grpc_rb_call_credentials invoking user callback:|%s| "
+              "(failed to get source filename and line) with arguments:|%s|",
+              StringValueCStr(callback_func_str),
+              StringValueCStr(callback_args_str));
+    }
+  }
+  VALUE metadata =
+      rb_funcall(callback_func, rb_intern("call"), 1, callback_args);
+  grpc_metadata_array* md_ary = NULL;
+  TypedData_Get_Struct(md_ary_obj, grpc_metadata_array,
+                       &grpc_rb_md_ary_data_type, md_ary);
+  grpc_rb_md_ary_convert(metadata, md_ary);
   rb_hash_aset(result, rb_str_new2("metadata"), metadata);
   rb_hash_aset(result, rb_str_new2("status"), INT2NUM(GRPC_STATUS_OK));
   rb_hash_aset(result, rb_str_new2("details"), rb_str_new2(""));
@@ -67,14 +98,23 @@ static VALUE grpc_rb_call_credentials_callback(VALUE callback_args) {
 static VALUE grpc_rb_call_credentials_callback_rescue(VALUE args,
                                                       VALUE exception_object) {
   VALUE result = rb_hash_new();
-  VALUE backtrace =
-      rb_funcall(rb_funcall(exception_object, rb_intern("backtrace"), 0),
-                 rb_intern("join"), 1, rb_str_new2("\n\tfrom "));
+  VALUE backtrace = rb_funcall(exception_object, rb_intern("backtrace"), 0);
+  VALUE backtrace_str;
+  if (backtrace != Qnil) {
+    backtrace_str =
+        rb_funcall(backtrace, rb_intern("join"), 1, rb_str_new2("\n\tfrom "));
+  } else {
+    backtrace_str = rb_str_new2(
+        "failed to get backtrace, this exception was likely thrown from native "
+        "code");
+  }
   VALUE rb_exception_info =
       rb_funcall(exception_object, rb_intern("inspect"), 0);
   (void)args;
-  gpr_log(GPR_INFO, "Call credentials callback failed: %s\n%s",
-          StringValueCStr(rb_exception_info), StringValueCStr(backtrace));
+  gpr_log(GPR_INFO,
+          "GRPC_RUBY call credentials callback failed, exception inspect:|%s| "
+          "backtrace:|%s|",
+          StringValueCStr(rb_exception_info), StringValueCStr(backtrace_str));
   rb_hash_aset(result, rb_str_new2("metadata"), Qnil);
   rb_hash_aset(result, rb_str_new2("status"),
                INT2NUM(GRPC_STATUS_UNAUTHENTICATED));
@@ -98,17 +138,22 @@ static void grpc_rb_call_credentials_callback_with_gil(void* param) {
   rb_hash_aset(args, ID2SYM(rb_intern("jwt_aud_uri")), auth_uri);
   rb_ary_push(callback_args, params->get_metadata);
   rb_ary_push(callback_args, args);
+  // Wrap up the grpc_metadata_array into a ruby object and do the conversion
+  // from hash to grpc_metadata_array within the rescue block, because the
+  // conversion can throw exceptions.
+  rb_ary_push(callback_args,
+              TypedData_Wrap_Struct(grpc_rb_cMdAry, &grpc_rb_md_ary_data_type,
+                                    &md_ary));
   result = rb_rescue(grpc_rb_call_credentials_callback, callback_args,
                      grpc_rb_call_credentials_callback_rescue, Qnil);
   // Both callbacks return a hash, so result should be a hash
-  grpc_rb_md_ary_convert(rb_hash_aref(result, rb_str_new2("metadata")),
-                         &md_ary);
   status = NUM2INT(rb_hash_aref(result, rb_str_new2("status")));
   details = rb_hash_aref(result, rb_str_new2("details"));
   error_details = StringValueCStr(details);
   params->callback(params->user_data, md_ary.metadata, md_ary.count, status,
                    error_details);
   grpc_rb_metadata_array_destroy_including_entries(&md_ary);
+  grpc_auth_metadata_context_reset(&params->context);
   gpr_free(params);
 }
 
@@ -118,9 +163,9 @@ static int grpc_rb_call_credentials_plugin_get_metadata(
     grpc_metadata creds_md[GRPC_METADATA_CREDENTIALS_PLUGIN_SYNC_MAX],
     size_t* num_creds_md, grpc_status_code* status,
     const char** error_details) {
-  callback_params* params = gpr_malloc(sizeof(callback_params));
+  callback_params* params = gpr_zalloc(sizeof(callback_params));
   params->get_metadata = (VALUE)state;
-  params->context = context;
+  grpc_auth_metadata_context_copy(&context, &params->context);
   params->user_data = user_data;
   params->callback = cb;
 

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

@@ -135,6 +135,8 @@ grpc_google_refresh_token_credentials_create_type grpc_google_refresh_token_cred
 grpc_access_token_credentials_create_type grpc_access_token_credentials_create_import;
 grpc_google_iam_credentials_create_type grpc_google_iam_credentials_create_import;
 grpc_sts_credentials_create_type grpc_sts_credentials_create_import;
+grpc_auth_metadata_context_copy_type grpc_auth_metadata_context_copy_import;
+grpc_auth_metadata_context_reset_type grpc_auth_metadata_context_reset_import;
 grpc_metadata_credentials_create_from_plugin_type grpc_metadata_credentials_create_from_plugin_import;
 grpc_secure_channel_create_type grpc_secure_channel_create_import;
 grpc_server_credentials_release_type grpc_server_credentials_release_import;
@@ -407,6 +409,8 @@ void grpc_rb_load_imports(HMODULE library) {
   grpc_access_token_credentials_create_import = (grpc_access_token_credentials_create_type) GetProcAddress(library, "grpc_access_token_credentials_create");
   grpc_google_iam_credentials_create_import = (grpc_google_iam_credentials_create_type) GetProcAddress(library, "grpc_google_iam_credentials_create");
   grpc_sts_credentials_create_import = (grpc_sts_credentials_create_type) GetProcAddress(library, "grpc_sts_credentials_create");
+  grpc_auth_metadata_context_copy_import = (grpc_auth_metadata_context_copy_type) GetProcAddress(library, "grpc_auth_metadata_context_copy");
+  grpc_auth_metadata_context_reset_import = (grpc_auth_metadata_context_reset_type) GetProcAddress(library, "grpc_auth_metadata_context_reset");
   grpc_metadata_credentials_create_from_plugin_import = (grpc_metadata_credentials_create_from_plugin_type) GetProcAddress(library, "grpc_metadata_credentials_create_from_plugin");
   grpc_secure_channel_create_import = (grpc_secure_channel_create_type) GetProcAddress(library, "grpc_secure_channel_create");
   grpc_server_credentials_release_import = (grpc_server_credentials_release_type) GetProcAddress(library, "grpc_server_credentials_release");

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

@@ -380,6 +380,12 @@ extern grpc_google_iam_credentials_create_type grpc_google_iam_credentials_creat
 typedef grpc_call_credentials*(*grpc_sts_credentials_create_type)(const grpc_sts_credentials_options* options, void* reserved);
 extern grpc_sts_credentials_create_type grpc_sts_credentials_create_import;
 #define grpc_sts_credentials_create grpc_sts_credentials_create_import
+typedef void(*grpc_auth_metadata_context_copy_type)(grpc_auth_metadata_context* from, grpc_auth_metadata_context* to);
+extern grpc_auth_metadata_context_copy_type grpc_auth_metadata_context_copy_import;
+#define grpc_auth_metadata_context_copy grpc_auth_metadata_context_copy_import
+typedef void(*grpc_auth_metadata_context_reset_type)(grpc_auth_metadata_context* context);
+extern grpc_auth_metadata_context_reset_type grpc_auth_metadata_context_reset_import;
+#define grpc_auth_metadata_context_reset grpc_auth_metadata_context_reset_import
 typedef grpc_call_credentials*(*grpc_metadata_credentials_create_from_plugin_type)(grpc_metadata_credentials_plugin plugin, grpc_security_level min_security_level, void* reserved);
 extern grpc_metadata_credentials_create_from_plugin_type grpc_metadata_credentials_create_from_plugin_import;
 #define grpc_metadata_credentials_create_from_plugin grpc_metadata_credentials_create_from_plugin_import

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

@@ -30,18 +30,26 @@ module GRPC
   # https://github.com/grpc/grpc/blob/master/include/grpc/impl/codegen/status.h
   # for detailed descriptions of each status code.
   class BadStatus < StandardError
-    attr_reader :code, :details, :metadata
+    attr_reader :code, :details, :metadata, :debug_error_string
 
     include GRPC::Core::StatusCodes
 
     # @param code [Numeric] the status code
     # @param details [String] the details of the exception
     # @param metadata [Hash] the error's metadata
-    def initialize(code, details = 'unknown cause', metadata = {})
-      super("#{code}:#{details}")
+    def initialize(code,
+                   details = 'unknown cause',
+                   metadata = {},
+                   debug_error_string = nil)
+      exception_message = "#{code}:#{details}"
+      if debug_error_string
+        exception_message += ". debug_error_string:#{debug_error_string}"
+      end
+      super(exception_message)
       @code = code
       @details = details
       @metadata = metadata
+      @debug_error_string = debug_error_string
     end
 
     # Converts the exception to a {Struct::Status} for use in the networking
@@ -49,7 +57,7 @@ module GRPC
     #
     # @return [Struct::Status] with the same code and details
     def to_status
-      Struct::Status.new(code, details, metadata)
+      Struct::Status.new(code, details, metadata, debug_error_string)
     end
 
     # Converts the exception to a deserialized {Google::Rpc::Status} object.
@@ -66,8 +74,10 @@ module GRPC
       nil
     end
 
-    def self.new_status_exception(code, details = 'unknown cause',
-                                  metadata = {})
+    def self.new_status_exception(code,
+                                  details = 'unknown cause',
+                                  metadata = {},
+                                  debug_error_string = nil)
       codes = {}
       codes[OK] = Ok
       codes[CANCELLED] = Cancelled
@@ -88,129 +98,180 @@ module GRPC
       codes[DATA_LOSS] = DataLoss
 
       if codes[code].nil?
-        BadStatus.new(code, details, metadata)
+        BadStatus.new(code, details, metadata, debug_error_string)
       else
-        codes[code].new(details, metadata)
+        codes[code].new(details, metadata, debug_error_string)
       end
     end
   end
 
   # GRPC status code corresponding to status OK
   class Ok < BadStatus
-    def initialize(details = 'unknown cause', metadata = {})
-      super(Core::StatusCodes::OK, details, metadata)
+    def initialize(details = 'unknown cause',
+                   metadata = {},
+                   debug_error_string = nil)
+      super(Core::StatusCodes::OK,
+            details, metadata, debug_error_string)
     end
   end
 
   # GRPC status code corresponding to status CANCELLED
   class Cancelled < BadStatus
-    def initialize(details = 'unknown cause', metadata = {})
-      super(Core::StatusCodes::CANCELLED, details, metadata)
+    def initialize(details = 'unknown cause',
+                   metadata = {},
+                   debug_error_string = nil)
+      super(Core::StatusCodes::CANCELLED,
+            details, metadata, debug_error_string)
     end
   end
 
   # GRPC status code corresponding to status UNKNOWN
   class Unknown < BadStatus
-    def initialize(details = 'unknown cause', metadata = {})
-      super(Core::StatusCodes::UNKNOWN, details, metadata)
+    def initialize(details = 'unknown cause',
+                   metadata = {},
+                   debug_error_string = nil)
+      super(Core::StatusCodes::UNKNOWN,
+            details, metadata, debug_error_string)
     end
   end
 
   # GRPC status code corresponding to status INVALID_ARGUMENT
   class InvalidArgument < BadStatus
-    def initialize(details = 'unknown cause', metadata = {})
-      super(Core::StatusCodes::INVALID_ARGUMENT, details, metadata)
+    def initialize(details = 'unknown cause',
+                   metadata = {},
+                   debug_error_string = nil)
+      super(Core::StatusCodes::INVALID_ARGUMENT,
+            details, metadata, debug_error_string)
     end
   end
 
   # GRPC status code corresponding to status DEADLINE_EXCEEDED
   class DeadlineExceeded < BadStatus
-    def initialize(details = 'unknown cause', metadata = {})
-      super(Core::StatusCodes::DEADLINE_EXCEEDED, details, metadata)
+    def initialize(details = 'unknown cause',
+                   metadata = {},
+                   debug_error_string = nil)
+      super(Core::StatusCodes::DEADLINE_EXCEEDED,
+            details, metadata, debug_error_string)
     end
   end
 
   # GRPC status code corresponding to status NOT_FOUND
   class NotFound < BadStatus
-    def initialize(details = 'unknown cause', metadata = {})
-      super(Core::StatusCodes::NOT_FOUND, details, metadata)
+    def initialize(details = 'unknown cause',
+                   metadata = {},
+                   debug_error_string = nil)
+      super(Core::StatusCodes::NOT_FOUND,
+            details, metadata, debug_error_string)
     end
   end
 
   # GRPC status code corresponding to status ALREADY_EXISTS
   class AlreadyExists < BadStatus
-    def initialize(details = 'unknown cause', metadata = {})
-      super(Core::StatusCodes::ALREADY_EXISTS, details, metadata)
+    def initialize(details = 'unknown cause',
+                   metadata = {},
+                   debug_error_string = nil)
+      super(Core::StatusCodes::ALREADY_EXISTS,
+            details, metadata, debug_error_string)
     end
   end
 
   # GRPC status code corresponding to status PERMISSION_DENIED
   class PermissionDenied < BadStatus
-    def initialize(details = 'unknown cause', metadata = {})
-      super(Core::StatusCodes::PERMISSION_DENIED, details, metadata)
+    def initialize(details = 'unknown cause',
+                   metadata = {},
+                   debug_error_string = nil)
+      super(Core::StatusCodes::PERMISSION_DENIED,
+            details, metadata, debug_error_string)
     end
   end
 
   # GRPC status code corresponding to status UNAUTHENTICATED
   class Unauthenticated < BadStatus
-    def initialize(details = 'unknown cause', metadata = {})
-      super(Core::StatusCodes::UNAUTHENTICATED, details, metadata)
+    def initialize(details = 'unknown cause',
+                   metadata = {},
+                   debug_error_string = nil)
+      super(Core::StatusCodes::UNAUTHENTICATED,
+            details, metadata, debug_error_string)
     end
   end
 
   # GRPC status code corresponding to status RESOURCE_EXHAUSTED
   class ResourceExhausted < BadStatus
-    def initialize(details = 'unknown cause', metadata = {})
-      super(Core::StatusCodes::RESOURCE_EXHAUSTED, details, metadata)
+    def initialize(details = 'unknown cause',
+                   metadata = {},
+                   debug_error_string = nil)
+      super(Core::StatusCodes::RESOURCE_EXHAUSTED,
+            details, metadata, debug_error_string)
     end
   end
 
   # GRPC status code corresponding to status FAILED_PRECONDITION
   class FailedPrecondition < BadStatus
-    def initialize(details = 'unknown cause', metadata = {})
-      super(Core::StatusCodes::FAILED_PRECONDITION, details, metadata)
+    def initialize(details = 'unknown cause',
+                   metadata = {},
+                   debug_error_string = nil)
+      super(Core::StatusCodes::FAILED_PRECONDITION,
+            details, metadata, debug_error_string)
     end
   end
 
   # GRPC status code corresponding to status ABORTED
   class Aborted < BadStatus
-    def initialize(details = 'unknown cause', metadata = {})
-      super(Core::StatusCodes::ABORTED, details, metadata)
+    def initialize(details = 'unknown cause',
+                   metadata = {},
+                   debug_error_string = nil)
+      super(Core::StatusCodes::ABORTED,
+            details, metadata, debug_error_string)
     end
   end
 
   # GRPC status code corresponding to status OUT_OF_RANGE
   class OutOfRange < BadStatus
-    def initialize(details = 'unknown cause', metadata = {})
-      super(Core::StatusCodes::OUT_OF_RANGE, details, metadata)
+    def initialize(details = 'unknown cause',
+                   metadata = {},
+                   debug_error_string = nil)
+      super(Core::StatusCodes::OUT_OF_RANGE,
+            details, metadata, debug_error_string)
     end
   end
 
   # GRPC status code corresponding to status UNIMPLEMENTED
   class Unimplemented < BadStatus
-    def initialize(details = 'unknown cause', metadata = {})
-      super(Core::StatusCodes::UNIMPLEMENTED, details, metadata)
+    def initialize(details = 'unknown cause',
+                   metadata = {},
+                   debug_error_string = nil)
+      super(Core::StatusCodes::UNIMPLEMENTED,
+            details, metadata, debug_error_string)
     end
   end
 
   # GRPC status code corresponding to status INTERNAL
   class Internal < BadStatus
-    def initialize(details = 'unknown cause', metadata = {})
-      super(Core::StatusCodes::INTERNAL, details, metadata)
+    def initialize(details = 'unknown cause',
+                   metadata = {},
+                   debug_error_string = nil)
+      super(Core::StatusCodes::INTERNAL,
+            details, metadata, debug_error_string)
     end
   end
 
   # GRPC status code corresponding to status UNAVAILABLE
   class Unavailable < BadStatus
-    def initialize(details = 'unknown cause', metadata = {})
-      super(Core::StatusCodes::UNAVAILABLE, details, metadata)
+    def initialize(details = 'unknown cause',
+                   metadata = {},
+                   debug_error_string = nil)
+      super(Core::StatusCodes::UNAVAILABLE,
+            details, metadata, debug_error_string)
     end
   end
 
   # GRPC status code corresponding to status DATA_LOSS
   class DataLoss < BadStatus
-    def initialize(details = 'unknown cause', metadata = {})
-      super(Core::StatusCodes::DATA_LOSS, details, metadata)
+    def initialize(details = 'unknown cause',
+                   metadata = {},
+                   debug_error_string = nil)
+      super(Core::StatusCodes::DATA_LOSS,
+            details, metadata, debug_error_string)
     end
   end
 end