tonic-rails 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 338a8abe3329b9c34aeb471e4b1b152696ae0a371ded6e375f2d42807775a8a2
-  data.tar.gz: 3ed3aedfabbde45d5ef7ed7598a2937f88232a0becaf93a0e3f17a9f8073503c
+  metadata.gz: d6cc5ee93380e004201e88f63289b88dff01dd6cc6566c92a3d972b9c934150d
+  data.tar.gz: 20a5a45adb019fa7275330b2d5b9f256a9f259765e1ffc83f4f1278902b38620
 SHA512:
-  metadata.gz: eefe02d7dbed4dae8bf2d9af2743823877f8468d933b406f0e76f2b848de789c9dee0a95778804186c025aeffc60ea24dc28edc6f5645100e5c7d25dfd1c93ec
-  data.tar.gz: 2b9eaa3a25ca8fe7091bb761ddaf86a15564f187252045a81a24e8ce96f50da50479f2b2af108ccd5804c3c5b4ee3055000f54624fdc8f97a0aa223d8df421bd
+  metadata.gz: 452568660e7a6f19c16d77ff8d272691c0f54c7ebf67261e5199dab6ad59f6c1df89b4b8e0efab84748e089bd74f4e4c2bf4de7dd599e628de0fc11f6ce03922
+  data.tar.gz: 52d5199c4d503c0792d84d254442a87cc25fc962b9af87561129c08c95974c48424c1a8914bd0cfcf664331d5c2f892c6cd8f31e507309bacb8c32b3ecc2fb53

data/CHANGELOG.md

@@ -7,6 +7,27 @@ minor versions may contain breaking changes.
 
 ## [Unreleased]
 
+## [0.8.0] - 2026-10-12
+
+### Added
+
+- Client: `method_retries:` sets retry policies per service
+  (`"demo.v1.ItemService"`) or per method
+  (`"demo.v1.ItemService/GetItem"`), like gRPC's service config. The most
+  specific setting wins: the call's `retries:`, then the method, then the
+  service, then the client's `retries:`.
+
+### Fixed
+
+- Windows: the process could crash with a segfault under load (#41). The
+  extension's locks spun and then called `Sleep`, which the mingw linker
+  bound to the `Sleep` that Ruby's DLL exports instead of the system's,
+  and Ruby's version crashes on threads Ruby doesn't own. Locks now come
+  from Rust's standard library, which doesn't spin through `Sleep`, the
+  build binds `Sleep` to kernel32, and CI checks that the Windows build
+  imports nothing but Ruby's C API from Ruby's DLL. 0.6.0 and 0.7.0 crashed in about 1 in 5 runs of the test suite;
+  earlier versions could crash in the same way, but rarely.
+
 ## [0.7.0] - 2026-10-11
 
 ### Added
@@ -186,7 +207,8 @@ First public release.
 - Precompiled native gems for Linux (x86_64, aarch64; glibc and musl) and
   macOS (x86_64, arm64), Ruby 3.3 to 4.0.
 
-[Unreleased]: https://github.com/CodingAnarchy/tonic-rails/compare/v0.7.0...HEAD
+[Unreleased]: https://github.com/CodingAnarchy/tonic-rails/compare/v0.8.0...HEAD
+[0.8.0]: https://github.com/CodingAnarchy/tonic-rails/compare/v0.7.0...v0.8.0
 [0.7.0]: https://github.com/CodingAnarchy/tonic-rails/compare/v0.6.0...v0.7.0
 [0.6.0]: https://github.com/CodingAnarchy/tonic-rails/compare/v0.5.0...v0.6.0
 [0.5.0]: https://github.com/CodingAnarchy/tonic-rails/compare/v0.4.0...v0.5.0

data/Cargo.lock

@@ -468,15 +468,6 @@ dependencies = [
  "windows-link",
 ]
 
-[[package]]
-name = "lock_api"
-version = "0.4.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965"
-dependencies = [
- "scopeguard",
-]
-
 [[package]]
 name = "log"
 version = "0.4.34"
@@ -573,29 +564,6 @@ version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7c87def4c32ab89d880effc9e097653c8da5d6ef28e6b539d313baaacfbafcbe"
 
-[[package]]
-name = "parking_lot"
-version = "0.12.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "93857453250e3077bd71ff98b6a65ea6621a19bb0f559a85248955ac12c45a1a"
-dependencies = [
- "lock_api",
- "parking_lot_core",
-]
-
-[[package]]
-name = "parking_lot_core"
-version = "0.9.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1"
-dependencies = [
- "cfg-if",
- "libc",
- "redox_syscall",
- "smallvec",
- "windows-link",
-]
-
 [[package]]
 name = "percent-encoding"
 version = "2.3.2"
@@ -708,15 +676,6 @@ version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cca7ad6a7e21e72151d56fe2495a259b5670e204c3adac41ee7ef676ea08117a"
 
-[[package]]
-name = "redox_syscall"
-version = "0.5.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d"
-dependencies = [
- "bitflags",
-]
-
 [[package]]
 name = "regex"
 version = "1.13.1"
@@ -822,12 +781,6 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
-[[package]]
-name = "scopeguard"
-version = "1.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
-
 [[package]]
 name = "security-framework"
 version = "3.7.0"
@@ -1107,7 +1060,7 @@ dependencies = [
 
 [[package]]
 name = "tonic_rails_native"
-version = "0.7.0"
+version = "0.8.0"
 dependencies = [
  "axum",
  "base64",
@@ -1118,7 +1071,6 @@ dependencies = [
  "http-body",
  "http-body-util",
  "magnus",
- "parking_lot",
  "prost",
  "prost-types",
  "rb-sys",

data/README.md

@@ -518,6 +518,24 @@ items.get_item({ id: 1 }, retries: false)                    # not this call
 items.get_item({ id: 1 }, retries: { max_attempts: 5 })      # or differently
 ```
 
+Different methods often need different policies: a read can retry more
+eagerly than a write. `method_retries:` sets them per service or per
+method, by their protobuf names:
+
+```ruby
+ITEMS = Tonic::Rails::Client.new(
+  "items.internal:50051",
+  retries: true,                                                   # every call...
+  method_retries: {
+    "demo.v1.ItemService/GetItem" => { max_attempts: 5 },          # ...but this method,
+    "demo.v1.AdminService" => false,                               # and this whole service
+  },
+)
+```
+
+The most specific setting wins: the call's own `retries:`, then its
+method's entry, then its service's, then the client's `retries:`.
+
 `retries: true` tries a call up to 3 times when it fails with
 `UNAVAILABLE`. A Hash changes any of these:
 
@@ -612,6 +630,7 @@ the client is created, not on the first call.
 | `max_message_size` | 4 MiB | largest message sent or received |
 | `connect_timeout` | 5 | seconds to wait for a connection |
 | `retries` | `false` | retry calls the server never started on; see [Retries](#retries) |
+| `method_retries` | `{}` | retries per service or method, by name |
 | `logger` | `Tonic::Rails.configuration.logger` | where retries are logged |
 
 ### Fork safety

data/ext/tonic_rails_native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tonic_rails_native"
-version = "0.7.0"
+version = "0.8.0"
 edition = "2024"
 rust-version = "1.88"
 publish = false
@@ -41,7 +41,6 @@ tokio-stream = { version = "0.1", features = ["net"] }
 prost = "0.14"
 prost-types = "0.14"
 socket2 = { version = "0.6", features = ["all"] }
-parking_lot = "0.12"
 crossbeam-channel = "0.5"
 http = "1"
 http-body = "1"

data/ext/tonic_rails_native/extconf.rb

@@ -1,7 +1,35 @@
 # frozen_string_literal: true
 
+require "fileutils"
 require "mkmf"
 require "rb_sys/mkmf"
+require "shellwords"
+
+# On mingw, Ruby's DLL exports its own `Sleep`, which releases the GVL
+# around the wait: on a thread Ruby doesn't own it crashes, and on a Ruby
+# thread that has already released the GVL it takes the GVL back from
+# whichever thread holds it (#41).  rb-sys links Ruby's import library ahead of
+# kernel32, so the extension's `Sleep` (from mingw's DLL startup code, and
+# from std via crossbeam) would bind to Ruby's.  Link a one-function import
+# library binding `Sleep` to kernel32 ahead of Ruby's instead.  (Putting
+# all of kernel32 first goes too far: some toolchains' kernel32 import
+# libraries claim functions kernel32.dll doesn't export.)
+# script/check_windows_imports.rb checks the result in CI.
+if RbConfig::CONFIG["target_os"].to_s.include?("mingw")
+  dir = File.expand_path("kernel32_sleep")
+  FileUtils.mkdir_p(dir)
+  File.write(File.join(dir, "sleep.def"), "LIBRARY kernel32.dll\nEXPORTS\nSleep\n")
+  # Cross-compiling, RbConfig describes the target, so its DLLTOOL may not
+  # exist here: try the one next to the C compiler too.
+  compiler = Shellwords.split(RbConfig::CONFIG["CC"].to_s).find { |word| word.include?("gcc") }.to_s
+  candidates = [RbConfig::CONFIG["DLLTOOL"], compiler.sub(/gcc(\.exe)?\z/, "dlltool"), "dlltool"]
+  dlltool = candidates.reject { |tool| tool.to_s.empty? }.uniq.find { |tool| find_executable(tool) }
+  abort "tonic-rails: no dlltool found (tried #{candidates.compact.uniq.join(', ')})" unless dlltool
+  unless system(dlltool, "-d", File.join(dir, "sleep.def"), "-l", File.join(dir, "libtonic_rails_sleep.a"))
+    abort "tonic-rails: #{dlltool} failed to build the kernel32 Sleep import library"
+  end
+  RbConfig::CONFIG["LIBS"] = "-L#{Shellwords.escape(dir)} -ltonic_rails_sleep #{RbConfig::CONFIG['LIBS']}"
+end
 
 # Builds the Rust crate with cargo and installs the library as
 # lib/tonic/rails/tonic_rails_native.{so,bundle}, matching

data/ext/tonic_rails_native/src/client.rs

@@ -24,7 +24,6 @@ use bytes::{Buf, BufMut, Bytes};
 use http::uri::PathAndQuery;
 use http::{HeaderMap, HeaderName, HeaderValue};
 use magnus::{Error, RArray, RHash, RString, Ruby, r_hash::ForEach};
-use parking_lot::Mutex;
 use tokio::runtime::{Builder, Handle, Runtime};
 use tokio::sync::mpsc;
 use tokio::task::JoinHandle;
@@ -34,6 +33,7 @@ use tonic::transport::{Certificate, Channel, ClientTlsConfig, Endpoint, Identity
 use tonic::{Code, Request, Status};
 
 use crate::gvl::{Cancel, Wait, block_on, recv_blocking, without_gvl};
+use crate::sync::Mutex;
 
 // ─── Per-process runtime ──────────────────────────────────────────
 

data/ext/tonic_rails_native/src/gvl.rs

@@ -16,11 +16,11 @@ use std::sync::atomic::{AtomicBool, AtomicU32, Ordering};
 use std::task::{Context, Poll, Wake, Waker};
 
 use crate::log::{Level, LogSink};
+use crate::sync::{Condvar, Mutex};
 use magnus::{
     Error, RHash, RString, Ruby, Value, prelude::*, r_hash::ForEach, typed_data::DataTypeFunctions,
     value::Opaque,
 };
-use parking_lot::{Condvar, Mutex};
 use rb_sys::{RB_NOGVL_INTR_FAIL, rb_nogvl, rb_thread_call_with_gvl};
 use tokio::sync::{Notify, mpsc};
 
@@ -101,7 +101,7 @@ where
 /// Minimal single-future executor that parks the current (non-tokio)
 /// thread.  tokio's channel and `Notify` futures are runtime-agnostic.
 ///
-/// It parks on a pthread condition variable rather than
+/// It parks on a condition variable rather than
 /// `std::thread::park`, which on macOS uses libdispatch: libdispatch
 /// traps in the child of a multi-threaded process, and the client blocks
 /// here in processes forked after it made calls.
@@ -131,7 +131,7 @@ pub fn block_on<F: Future>(fut: F) -> F::Output {
         }
         let mut woken = signal.woken.lock();
         while !*woken {
-            signal.condvar.wait(&mut woken);
+            woken = signal.condvar.wait(woken);
         }
         *woken = false;
     }

data/ext/tonic_rails_native/src/lib.rs

@@ -35,6 +35,7 @@ mod gvl;
 mod log;
 mod net;
 mod server;
+mod sync;
 
 use magnus::{Error, Ruby, function, method, prelude::*};
 

data/ext/tonic_rails_native/src/server.rs

@@ -22,7 +22,6 @@ use std::time::{Duration, Instant};
 use magnus::{
     Error, RArray, RHash, RString, Ruby, TryConvert, Value, gc, typed_data::DataTypeFunctions, value::Opaque,
 };
-use parking_lot::Mutex;
 use prost::Message;
 use tokio::runtime::Runtime;
 use tokio::sync::{Semaphore, watch};
@@ -37,6 +36,7 @@ use crate::dispatch::{DispatchInner, DispatchService};
 use crate::gvl::{self, Cancel, DispatchContext};
 use crate::log::{Level, LogEvent, LogSink};
 use crate::net::{LimitedIncoming, bind, listen, listen_inherited};
+use crate::sync::Mutex;
 
 /// The overall-server health entry (empty service name).
 const OVERALL: &str = "";

data/ext/tonic_rails_native/src/sync.rs

@@ -0,0 +1,42 @@
+//! `Mutex` and `Condvar` over `std::sync`, with parking_lot's API: `lock`
+//! returns the guard, and a panic while holding a lock doesn't poison it.
+//!
+//! Why not parking_lot: under contention it spins and then calls `Sleep`,
+//! and on Windows (mingw) the extension's `Sleep` import binds to the one
+//! Ruby's DLL exports.  Ruby's `Sleep` expects a Ruby thread, so on a tokio
+//! thread it crashed the process (#41).  std's locks use SRW locks and
+//! never call `Sleep`.
+
+use std::sync::{MutexGuard, PoisonError};
+
+#[derive(Default)]
+pub struct Mutex<T>(std::sync::Mutex<T>);
+
+impl<T> Mutex<T> {
+    pub const fn new(value: T) -> Self {
+        Self(std::sync::Mutex::new(value))
+    }
+
+    pub fn lock(&self) -> MutexGuard<'_, T> {
+        self.0.lock().unwrap_or_else(PoisonError::into_inner)
+    }
+
+    pub fn get_mut(&mut self) -> &mut T {
+        self.0.get_mut().unwrap_or_else(PoisonError::into_inner)
+    }
+}
+
+#[derive(Default)]
+pub struct Condvar(std::sync::Condvar);
+
+impl Condvar {
+    /// Block until notified, releasing `guard` meanwhile.  Wakes can be
+    /// spurious: wait in a loop on the condition.
+    pub fn wait<'a, T>(&self, guard: MutexGuard<'a, T>) -> MutexGuard<'a, T> {
+        self.0.wait(guard).unwrap_or_else(PoisonError::into_inner)
+    }
+
+    pub fn notify_one(&self) {
+        self.0.notify_one();
+    }
+}

data/lib/tonic/rails/client.rb

@@ -16,6 +16,7 @@ module Tonic
     #
     # Retries are opt-in: `retries: true` (or a Hash; see RetryPolicy) on
     # the client or a call retries calls the server never started on.
+    # `method_retries:` sets them per service or method.
     #
     # Stubs are built from the protobuf descriptors that
     # `tonic_rails:compile_protos` (protoc --ruby_out) generates; no
@@ -46,6 +47,10 @@ module Tonic
       # @return [RetryPolicy, nil] how calls are retried, unless they say otherwise
       attr_reader :retries
 
+      # @return [Hash{String=>RetryPolicy, nil}] retry policies by service or
+      #   method name, which take precedence over #retries
+      attr_reader :method_retries
+
       # @param address [String] "host:port"
       # @param tls [Boolean] false for plaintext, which must be explicit
       # @param tls_ca_path [String, nil] CA certificates (PEM) to trust instead
@@ -61,11 +66,15 @@ module Tonic
       # @param connect_timeout [Numeric] seconds to wait for a connection
       # @param retries [RetryPolicy, Hash, Boolean] retry calls the server
       #   never started on (see RetryPolicy); off by default
+      # @param method_retries [Hash{String=>RetryPolicy, Hash, Boolean}]
+      #   retries for some services ("demo.v1.ItemService") or methods
+      #   ("demo.v1.ItemService/GetItem"), instead of `retries`.  A method's
+      #   entry beats its service's.
       # @param logger [Logger, nil] where retries are logged; defaults to
       #   Tonic::Rails.configuration.logger
       def initialize(address, tls: true, tls_ca_path: nil, tls_cert_path: nil, tls_key_path: nil,
                      tls_server_name: nil, deadline: nil, metadata: {}, max_message_size: DEFAULT_MAX_MESSAGE_SIZE,
-                     connect_timeout: 5, retries: false, logger: nil)
+                     connect_timeout: 5, retries: false, method_retries: {}, logger: nil)
         Tonic::Rails.native_extension!
         validate_address!(address)
         validate_tls!(tls, tls_cert_path, tls_key_path)
@@ -78,6 +87,7 @@ module Tonic
         @address = address
         @deadline = deadline
         @retries = RetryPolicy.from(retries)
+        @method_retries = method_retry_policies(method_retries)
         @logger = logger
         @metadata = Metadata.encode(metadata)
         @stubs = {}
@@ -127,7 +137,7 @@ module Tonic
         bytes = input.encode(request_message(path, input, request))
         metadata = call_metadata(metadata)
         deadline_at = deadline_at(deadline)
-        policy = retry_policy(retries)
+        policy = retry_policy(path, retries)
 
         Instrumentation.instrument_request(path, address, metadata) do |payload|
           code, error_message, response, headers, trailers, details = with_retries(path, policy, deadline_at, payload) do
@@ -150,7 +160,7 @@ module Tonic
         # Fixed now, so the stream keeps the deadline of the RPC this
         # thread is handling even if it's read later.
         deadline_at = deadline_at(deadline)
-        policy = retry_policy(retries)
+        policy = retry_policy(path, retries)
 
         ServerStream.new(path) do |stream, block|
           Instrumentation.instrument_request(path, address, metadata) do |payload|
@@ -238,8 +248,35 @@ module Tonic
         (remaining * 1000).ceil
       end
 
-      def retry_policy(retries)
-        retries.nil? ? @retries : RetryPolicy.from(retries)
+      METHOD_NAME = %r{\A[A-Za-z_][\w.]*(/[A-Za-z_]\w*)?\z}
+      private_constant :METHOD_NAME
+
+      def method_retry_policies(option)
+        raise ArgumentError, "method_retries must be a Hash" unless option.is_a?(Hash)
+
+        option.to_h do |name, retries|
+          name = name.to_s.delete_prefix("/")
+          unless name.match?(METHOD_NAME)
+            raise ArgumentError, "method_retries keys must be \"package.Service\" or \"package.Service/Method\", " \
+                                 "got #{name.inspect}"
+          end
+
+          [name, RetryPolicy.from(retries)]
+        end.freeze
+      end
+
+      # The most specific policy for a call: its own, its method's, its
+      # service's, then the client's.
+      def retry_policy(path, retries)
+        return RetryPolicy.from(retries) unless retries.nil?
+        return @retries if @method_retries.empty?
+
+        method = path.delete_prefix("/")
+        service = method.split("/", 2).first
+        return @method_retries[method] if @method_retries.key?(method)
+        return @method_retries[service] if @method_retries.key?(service)
+
+        @retries
       end
 
       # Yield each message of a native stream, then return its result.

data/lib/tonic/rails/version.rb

@@ -2,6 +2,6 @@
 
 module Tonic
   module Rails
-    VERSION = "0.7.0"
+    VERSION = "0.8.0"
   end
 end

data/lib/tonic-rails.rb

@@ -81,11 +81,13 @@ module Tonic
         # Precompiled platform gems ship one binary per Ruby minor version.
         ruby_version = RUBY_VERSION[/\d+\.\d+/]
         require "tonic/rails/#{ruby_version}/tonic_rails_native"
-      rescue LoadError
+      rescue LoadError => versioned
         begin
           require "tonic/rails/tonic_rails_native"
         rescue LoadError => e
-          @native_load_error = e
+          # A precompiled binary that exists but won't load says more than
+          # the missing fallback does.
+          @native_load_error = versioned.message.include?("cannot load such file") ? e : versioned
         end
       end
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tonic-rails
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Matt Tanous
@@ -81,6 +81,7 @@ files:
 - ext/tonic_rails_native/src/log.rs
 - ext/tonic_rails_native/src/net.rs
 - ext/tonic_rails_native/src/server.rs
+- ext/tonic_rails_native/src/sync.rs
 - lib/generators/tonic_rails/install/install_generator.rb
 - lib/generators/tonic_rails/install/templates/tonic_rails.rb.tt
 - lib/generators/tonic_rails/service/service_generator.rb