tonic-rails 0.7.0 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 338a8abe3329b9c34aeb471e4b1b152696ae0a371ded6e375f2d42807775a8a2
-  data.tar.gz: 3ed3aedfabbde45d5ef7ed7598a2937f88232a0becaf93a0e3f17a9f8073503c
+  metadata.gz: cd7973d8a7b1550f1f483912639ec1cbec562297c3368c8751c45780e8472ec1
+  data.tar.gz: 385c74ea7100d36e7c128df6f1feda64fb7ac7c3b11a3905afa35d5ac275af26
 SHA512:
-  metadata.gz: eefe02d7dbed4dae8bf2d9af2743823877f8468d933b406f0e76f2b848de789c9dee0a95778804186c025aeffc60ea24dc28edc6f5645100e5c7d25dfd1c93ec
-  data.tar.gz: 2b9eaa3a25ca8fe7091bb761ddaf86a15564f187252045a81a24e8ce96f50da50479f2b2af108ccd5804c3c5b4ee3055000f54624fdc8f97a0aa223d8df421bd
+  metadata.gz: d491ec733022fca2b343ca3bb738273945c62614619266a1bccc8e8823f9f377628a2e6b4fb9a4b9c367b623e4c523ace580e18e4094fd66b07f94b7b55a0b97
+  data.tar.gz: 58a0d85837cd8f68f063d934b029761ab4239d30b9e2807bed5638b798ac1b18d2efe3e88c20c255dbb5c18aa3a5fee79ba86a8056d785eced8690ce4a6d0c17

data/CHANGELOG.md

@@ -7,6 +7,37 @@ minor versions may contain breaking changes.
 
 ## [Unreleased]
 
+## [0.8.1] - 2026-10-13
+
+### Fixed
+
+- Client: a call whose deadline passed could raise `CANCELLED` ("Timeout
+  expired") instead of `DEADLINE_EXCEEDED` (#48), mostly on Windows.
+  tonic enforces the deadline too, and when its timer fired first the
+  call ended with its status. Calls now raise `DEADLINE_EXCEEDED`
+  whichever timer fires first.
+
+## [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 +217,9 @@ 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.1...HEAD
+[0.8.1]: https://github.com/CodingAnarchy/tonic-rails/compare/v0.8.0...v0.8.1
+[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.1"
 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.1"
 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,16 +24,16 @@ 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;
 use tonic::codec::{Codec, DecodeBuf, Decoder, EncodeBuf, Encoder, Streaming};
 use tonic::metadata::MetadataMap;
 use tonic::transport::{Certificate, Channel, ClientTlsConfig, Endpoint, Identity};
-use tonic::{Code, Request, Status};
+use tonic::{Code, Request, Status, TimeoutExpired};
 
 use crate::gvl::{Cancel, Wait, block_on, recv_blocking, without_gvl};
+use crate::sync::Mutex;
 
 // ─── Per-process runtime ──────────────────────────────────────────
 
@@ -218,13 +218,22 @@ async fn with_timeout(call: impl Future<Output = Outcome>, timeout: Option<Durat
     let started = tokio::time::Instant::now();
     let outcome = tokio::time::timeout(timeout, call).await;
     match outcome {
-        // tonic's channel enforces the grpc-timeout header too, but ends
-        // the call with its own status.
-        Ok(outcome) if !(outcome.local && started.elapsed() >= timeout) => outcome,
+        Ok(outcome) if !(outcome.local && started.elapsed() >= timeout) && !timeout_expired(&outcome) => {
+            outcome
+        }
         _ => Outcome::error(Code::DeadlineExceeded, "deadline exceeded"),
     }
 }
 
+/// tonic's channel enforces the grpc-timeout header too, and when its timer
+/// fires before ours it ends the call with CANCELLED "Timeout expired", with
+/// no source to mark it local.  (A tonic server enforcing the same deadline
+/// sends that status too.)  Coarse timers, like Windows' 15 ms ticks, let
+/// it fire first even though ours started earlier (#48).
+fn timeout_expired(outcome: &Outcome) -> bool {
+    outcome.code == Code::Cancelled && outcome.message == TimeoutExpired(()).to_string()
+}
+
 /// What every call needs: the method, one request message and its metadata.
 struct CallArgs {
     channel: Channel,
@@ -663,3 +672,42 @@ fn append_causes(mut message: String, mut source: Option<&dyn std::error::Error>
     }
     message
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn run(call: impl Future<Output = Outcome>, timeout: Option<Duration>) -> Outcome {
+        let runtime = Builder::new_current_thread().enable_time().build().unwrap();
+        runtime.block_on(with_timeout(call, timeout))
+    }
+
+    async fn status(status: Status) -> Outcome {
+        Outcome::status(status, None)
+    }
+
+    #[test]
+    fn tonics_timeout_is_a_deadline_however_early_it_fires() {
+        let outcome = run(
+            status(Status::cancelled("Timeout expired")),
+            Some(Duration::from_secs(60)),
+        );
+        assert_eq!(outcome.code, Code::DeadlineExceeded);
+    }
+
+    #[test]
+    fn other_cancellations_stay_cancelled() {
+        let outcome = run(
+            status(Status::cancelled("client went away")),
+            Some(Duration::from_secs(60)),
+        );
+        assert_eq!(outcome.code, Code::Cancelled);
+        assert_eq!(outcome.message, "client went away");
+    }
+
+    #[test]
+    fn our_timer_is_a_deadline() {
+        let outcome = run(std::future::pending(), Some(Duration::from_millis(10)));
+        assert_eq!(outcome.code, Code::DeadlineExceeded);
+    }
+}

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.1"
   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.1
 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