questdb 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6fec92034e9c3564a4ad1ebfcf5db83d2d29458880767082552dca3af8a2630b
-  data.tar.gz: e12d85e1409867bbaccaa26417ee1fb1fb5c232959978a137008686b9139d34c
+  metadata.gz: 8ee4c4fb9e29b76cf567494acba3f14416fd364efef44e9f2d2c7d19ea0c25fb
+  data.tar.gz: 5abe1a191ded582c1cd6f9cb5353eaaa6cca4b4d73b985b78c9b3900c2352ed4
 SHA512:
-  metadata.gz: a6168546fc44481d4548f927f795f267ec73a5acde1282b0c8feaf5fe4ceda1c4e4e9cd80c300e2ec096cf68ebf2d06649364ecb7c632800f83e3172917bf968
-  data.tar.gz: 995838f049b7c23f06f4be2ce8a45a83c6bdd13e348dc6bae071cd42ff1bdb2eb73f75ec9155c425a69bb041ee794581dd6f265b3938cf24acf2409c7436f0e7
+  metadata.gz: 0d824b5d90da424043ffd261e185e827495afac15e76dde355f268fe1dfa80b1de6d9a1282f3ab514e8b2b5b65d793ce5871b2c9bbda8b40838de97df8aeef2c
+  data.tar.gz: 4648bc7748d704d652706b94744d4a739714351641c20b08a2228309246dca38a194fff11f10dc93d4fcc3cc919520015195647b7776fb86e1c128e13492f69b

data/.cargo/audit.toml

@@ -1,17 +1,25 @@
-# Temporary exceptions for the 0.1.0 release, which pins c-questdb-client
-# 7.1.0. Its lockfile has rustls 0.23.41; the fixes need rustls 0.23.46 or
-# newer. Remove each entry when a c-questdb-client patch release ships it.
-# See docs/releasing.md.
+# Temporary exceptions for the 0.1.x releases, which pin c-questdb-client
+# 7.1.0 and 7.2.0. Both lockfiles have rustls 0.23.41, rustls-webpki
+# 0.103.13 and webpki-roots 1.0.8; the fixes need rustls 0.23.46,
+# rustls-webpki 0.103.16 and webpki-roots 1.0.10 or newer. Remove each entry
+# when a c-questdb-client patch release ships it. See docs/releasing.md.
 [advisories]
 ignore = [
-    # TLS 1.3 handshake messages accepted across encryption level boundaries.
+    # rustls: TLS 1.3 handshake messages accepted across encryption level
+    # boundaries.
     "RUSTSEC-2026-0285",
-    # `Debug` impls for client session values expose TLS secrets.
+    # rustls: `Debug` impls for client session values expose TLS secrets.
     "RUSTSEC-2026-0346",
-    # Brotli certificate decompression can allocate up to 1 GiB; the brotli
-    # feature is not enabled in this build.
+    # rustls: Brotli certificate decompression can allocate up to 1 GiB; the
+    # brotli feature is not enabled in this build.
     "RUSTSEC-2026-0348",
-    # Unauthenticated ServerHello can downgrade later connections to
+    # rustls: unauthenticated ServerHello can downgrade later connections to
     # classical key exchange.
     "RUSTSEC-2026-0349",
+    # webpki-roots: bundled roots allow trust in distrusted emSign
+    # intermediates.
+    "RUSTSEC-2026-0381",
+    # rustls-webpki: certificate verification may accept distrusted
+    # intermediates.
+    "RUSTSEC-2026-0382",
 ]

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 0.1.1 (2026-10-21)
+
+- Fixed precompiled gems that installed but failed on `require "questdb"`. The 0.1.0 native extensions were linked against the Ruby on the build machine: macOS gems referenced that machine's `libruby` path (or, for Ruby 3.1 on ARM64, symbols in its `ruby` executable), and Linux gems required `libruby.so`, so they failed with Rubies built without a shared library. Extensions now resolve Ruby's C API from the Ruby that loads them. The release pipeline checks every extension's linkage, because install tests on the build machines cannot detect this.
+- Fixed `ack: :durable` without `request_durable_ack` enabled: `ingest_columns`, `ingest_arrow`, `flush(wait: true)`, and `wait` now raise `:invalid_api_call` before sending anything. Previously direct ingestion committed its rows and then raised an in-doubt error.
+- Updated to `c-questdb-client` 7.2.0. The `query_timeout_ms` connect-string key sets a client-side timeout for queries on servers that support it; an expired query raises `QuestDB::Error` with code `:query_timeout`. Standalone WebSocket flushes now check the full frame-size limit before writing anything.
+- Known issue: `c-questdb-client` 7.2.0 still locks rustls 0.23.41, rustls-webpki 0.103.13 and webpki-roots 1.0.8. In addition to the four rustls advisories listed for 0.1.0, RUSTSEC-2026-0381 (webpki-roots) and RUSTSEC-2026-0382 (rustls-webpki), both about trusting distrusted certificate intermediates, are temporarily ignored in `cargo audit` (`.cargo/audit.toml`) until a `c-questdb-client` patch release updates these crates.
+
 ## 0.1.0 (2026-10-19)
 
 Initial pre-1.0 release for early adopters. Public APIs may evolve before 1.0; delivery and acknowledgement semantics are intentional compatibility commitments and changes will be documented here.

data/README.md

@@ -1,6 +1,6 @@
 # QuestDB Ruby client
 
-`questdb` is an MRI Ruby client for QuestDB's native **QuestDB Wire Protocol (QWP)** over WebSocket. It is backed by the official `c-questdb-client` 7.1.0 C ABI and does not implement the protocol, networking, TLS, authentication, failover, or store-and-forward in Ruby.
+`questdb` is an MRI Ruby client for QuestDB's native **QuestDB Wire Protocol (QWP)** over WebSocket. It is backed by the official `c-questdb-client` 7.2.0 C ABI and does not implement the protocol, networking, TLS, authentication, failover, or store-and-forward in Ruby.
 
 The client provides a deployment-level connection pool, pooled row and direct columnar ingestion, streaming SQL queries, safe Ruby dispatch for lifecycle/rejection callbacks, and standalone QWP WebSocket senders. Query batches and callback values are copied into ordinary Ruby objects before borrowed native data expires. Legacy ILP transports are intentionally not part of this client.
 

data/THIRD_PARTY_NOTICES.md

@@ -130,8 +130,8 @@ powerfmt | 0.2.0 | MIT OR Apache-2.0
 ppv-lite86 | 0.2.21 | MIT OR Apache-2.0
 proc-macro2 | 1.0.106 | MIT OR Apache-2.0
 questdb-confstr | 0.1.1 | Apache-2.0
-questdb-rs | 7.1.0 | Apache-2.0
-questdb-rs-ffi | 7.1.0 | Apache-2.0 (upstream workspace license)
+questdb-rs | 7.2.0 | Apache-2.0
+questdb-rs-ffi | 7.2.0 | Apache-2.0 (upstream workspace license)
 quote | 1.0.46 | MIT OR Apache-2.0
 r-efi | 5.3.0 | MIT OR Apache-2.0 OR LGPL-2.1-or-later
 r-efi | 6.0.0 | MIT OR Apache-2.0 OR LGPL-2.1-or-later

data/docs/configuration.md

@@ -20,15 +20,16 @@ The Ruby-only keywords `connection_listener`, `error_handler`, `connection_event
 
 ## Native settings
 
-Settings are passed directly to `c-questdb-client` 7.1.0 so new native settings do not require a Ruby release. Important groups include:
+Settings are passed directly to `c-questdb-client` 7.2.0 so new native settings do not require a Ruby release. Important groups include:
 
 - pool: `sender_pool_min`, `sender_pool_max`, `query_pool_min`, `query_pool_max`, `acquire_timeout_ms`, `idle_timeout_ms`, `pool_reap`, `lazy_connect`;
 - reconnect/failover: `addr` (comma-separated endpoints), `target`, `zone`, `reconnect_initial_backoff_millis`, `reconnect_max_backoff_millis`, `reconnect_max_duration_millis`, `initial_connect_retry`;
 - store-and-forward: `sf_dir`, `sender_id`, `sf_max_segment_bytes`, `sf_max_total_bytes`, `sf_append_deadline_millis`, `sf_durability`, `sf_sync_interval_millis`, `drain_orphans`, `max_background_drainers`;
 - delivery: `request_durable_ack`, `close_flush_timeout_millis`, `max_buf_size`, `max_name_len`, `error_inbox_capacity`;
+- query: `query_timeout_ms` (expiry raises `:query_timeout`; servers without per-query timeout support reject queries with `:unsupported_server`);
 - authentication/TLS: `username`, `password`, `token`, `auth_timeout_ms`, `tls_verify`, `tls_ca`, `tls_roots`, `tls_roots_password`.
 
-Consult the matching upstream 7.1.0 connect-string reference for exact constraints. Unknown or invalid settings are rejected by the native parser.
+Consult the matching upstream 7.2.0 connect-string reference for exact constraints. Unknown or invalid settings are rejected by the native parser.
 
 Direct column ingestion borrows from the native direct sender pool and uses `acquire_timeout_ms`; initial direct connection retry is bounded by `reconnect_max_duration_millis`. `max_rows_per_batch` is a method argument rather than a connection setting. Direct writes do not use `sf_dir`, do not produce FSNs, and are unaffected by row auto-publish thresholds. `ack: :durable` still requires both `request_durable_ack=on` and server support.
 

data/docs/design.md

@@ -2,7 +2,7 @@
 
 ## Native boundary
 
-The gem links statically to official `c-questdb-client` 7.1.0. Ruby owns thin typed-data wrappers for:
+The gem links statically to official `c-questdb-client` 7.2.0. Ruby owns thin typed-data wrappers for:
 
 - one ref-counted `questdb_db` pool state;
 - short-lived borrowed `qwp_sender` leases;

data/docs/python-parity.md

@@ -1,6 +1,6 @@
 # Python QWP parity
 
-This client tracks the QWP surface of the QuestDB Python 5.0 client at the `c-questdb-client` 7.1.0 ABI boundary. Parity means equivalent delivery, lifecycle, type, and error semantics expressed idiomatically in Ruby; it does not mean retaining Python's legacy ILP APIs.
+This client tracks the QWP surface of the QuestDB Python 5.0 client at the `c-questdb-client` 7.2.0 ABI boundary. Parity means equivalent delivery, lifecycle, type, and error semantics expressed idiomatically in Ruby; it does not mean retaining Python's legacy ILP APIs.
 
 | Python QWP capability | Ruby API | Status |
 | --- | --- | --- |

data/docs/releasing.md

@@ -17,7 +17,7 @@ The versioned layout is required because MRI's native ABI and `libruby` soname m
 
 1. Update `QuestDB::Ingress::VERSION` and change the changelog heading from `unreleased` to the intended release date.
 2. Build from a clean candidate commit with recursively initialized submodules on approved QuestDB infrastructure.
-3. Require Ruby and Rust dependency audits to pass without ignored advisories. Temporary exception for 0.1.0: the rustls advisories listed in `.cargo/audit.toml` are ignored until a patch release moves `c-questdb-client` to rustls 0.23.46 or newer; remove each ignore as soon as its fix ships. Enterprise-only durable-ACK qualification remains optional, matching the Python client's policy.
+3. Require Ruby and Rust dependency audits to pass without ignored advisories. Temporary exception for 0.1.x on `c-questdb-client` 7.1.0 and 7.2.0: the rustls, rustls-webpki and webpki-roots advisories listed in `.cargo/audit.toml` are ignored until a patch release moves `c-questdb-client` to rustls 0.23.46, rustls-webpki 0.103.16 and webpki-roots 1.0.10 or newer; remove each ignore as soon as its fix ships. Enterprise-only durable-ACK qualification remains optional, matching the Python client's policy.
 4. Run unit, integration, Arrow, native-memory, package, and bounded fault qualification. Shared-host benchmark results remain informational.
 5. Produce all eight gems, then run `script/verify-gem` on each final file and inspect native linkage. Clean-install each native gem on MRI 3.1, 3.2, 3.3, and 3.4 on its matching platform.
 6. Confirm the source gem installs with `CARGO_NET_OFFLINE=true` in a clean `GEM_HOME` and contains no generated extension or nested QuestDB server source.

data/ext/questdb_ingress/extconf.rb

@@ -24,6 +24,7 @@
 require "mkmf"
 require "rbconfig"
 require "fileutils"
+require_relative "unlink_build_ruby"
 
 root = File.expand_path("../..", __dir__)
 client = File.join(root, "vendor", "c-questdb-client")
@@ -73,5 +74,6 @@ when /mswin|mingw/
 else
   $LOCAL_LIBS << " -ldl -lpthread -lm -lrt -lutil"
 end
+QuestDBExtconf.unlink_build_ruby!(host_os)
 $CFLAGS << " -std=c11 -Wall -Wextra"
 create_makefile("questdb_ingress")

data/ext/questdb_ingress/questdb_ingress.c

@@ -509,6 +509,7 @@ static VALUE code_symbol(line_sender_error_code code)
         case line_sender_error_batch_too_large: name = "batch_too_large"; break;
         case line_sender_error_store_resend_required: name = "store_resend_required"; break;
         case line_sender_error_symbol_dict_full: name = "symbol_dict_full"; break;
+        case line_sender_error_query_timeout: name = "query_timeout"; break;
         default: name = "unknown_error"; break;
     }
     return ID2SYM(rb_intern(name));
@@ -4380,5 +4381,5 @@ void Init_questdb_ingress(void)
     rb_define_method(cNativeStandalone, "closed?", standalone_closed, 0);
     rb_define_method(cNativeStandalone, "close", standalone_close, 1);
 
-    rb_define_const(mNative, "C_CLIENT_VERSION", rb_str_new_cstr("7.1.0"));
+    rb_define_const(mNative, "C_CLIENT_VERSION", rb_str_new_cstr("7.2.0"));
 }

data/ext/questdb_ingress/unlink_build_ruby.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+#      ___                  _   ____  ____
+#     / _ \ _   _  ___  ___| |_|  _ \| __ )
+#    | | | | | | |/ _ \/ __| __| | | |  _ \
+#    | |_| | |_| |  __/\__ \ |_| |_| | |_) |
+#     \__\_\\__,_|\___||___/\__|____/|____/
+#
+#   Copyright (c) 2014-2019 Appsicle
+#   Copyright (c) 2019-2026 QuestDB
+#
+#   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.
+
+# Link flags for a native extension that must load in any Ruby, not just the
+# one that built it. Precompiled gems would otherwise depend on the build
+# Ruby's libruby path (or, for a static build Ruby, on symbols in its
+# executable). Leaving the Ruby C API unresolved lets it bind to whichever
+# Ruby loads the extension, static or shared.
+module QuestDBExtconf
+  BUNDLE_LOADER = /\s*(?:-bundle_loader\s+(?:'[^']*'|"[^"]*"|\S+)|-Wl,-bundle_loader,\S+)/
+  # Covers every form libruby reaches a link line in: the mkmf variables (for
+  # example EXTDLDFLAGS = "$(LIBRUBYARG_SHARED)" in Ruby 3.1 and 3.2 on macOS)
+  # and their expansions.
+  LIBRUBY = /\s*(?:\$\(LIBRUBYARG(?:_SHARED|_STATIC)?\)|-l\$\(RUBY_SO_NAME\)|-lruby[\w.-]*)/
+
+  module_function
+
+  # Call after `require "mkmf"` and before create_makefile.
+  def unlink_build_ruby!(host_os)
+    return if host_os.match?(/mswin|mingw/) # Windows extensions must import the Ruby DLL.
+
+    $LIBRUBYARG = ""
+    $LIBRUBYARG_SHARED = ""
+    return unless host_os.match?(/darwin/)
+
+    $DLDFLAGS = strip_build_ruby(String($DLDFLAGS))
+    %w[DLDFLAGS EXTDLDFLAGS].each do |key|
+      [RbConfig::MAKEFILE_CONFIG, RbConfig::CONFIG].each do |config|
+        config[key] = strip_build_ruby(config[key]) if config[key]
+      end
+    end
+    $DLDFLAGS << " -Wl,-undefined,dynamic_lookup" unless $DLDFLAGS.include?("dynamic_lookup")
+  end
+
+  def strip_build_ruby(flags)
+    flags.gsub(BUNDLE_LOADER, "").gsub(LIBRUBY, "")
+  end
+end

data/lib/questdb/arrow.rb

@@ -170,6 +170,7 @@ module QuestDB
       checkpoint_batches = Integer(checkpoint_batches)
       raise ArgumentError, "checkpoint_batches must be positive" unless checkpoint_batches.positive?
       @mutex.synchronize { ensure_open! }
+      ensure_durable_ack!(ack_level)
       Arrow.with_stream(source) do |capsule|
         @native.ingest_arrow(
           capsule, table, at_kind, at_value, overrides, ack_level, checkpoint_batches
@@ -201,6 +202,7 @@ module QuestDB
       checkpoint_batches = Integer(checkpoint_batches)
       raise ArgumentError, "checkpoint_batches must be positive" unless checkpoint_batches.positive?
       ensure_ws!
+      ensure_durable_ack!(ack_level)
       Arrow.with_stream(source) do |capsule|
         @native.ingest_arrow(
           @configuration, capsule, table, at_kind, at_value,

data/lib/questdb/client.rb

@@ -84,6 +84,7 @@ module QuestDB
       error_capacity = validate_capacity!(error_event_inbox_capacity, "error_event_inbox_capacity")
       parsed_settings = effective_settings || Config.parse(configuration)
       @auto_flush = parse_auto_flush(parsed_settings)
+      @durable_ack_requested = Config.durable_ack_requested?(parsed_settings)
       @mutex = Mutex.new
       @native = Ingress::Native::Client.new(
         configuration, !connection_listener.nil?, connection_capacity,
@@ -160,6 +161,7 @@ module QuestDB
         ack: ack
       )
       @mutex.synchronize { ensure_open! }
+      ensure_durable_ack!(prepared[6])
       return self if prepared[4].zero?
 
       @native.ingest_columns(*prepared)
@@ -249,6 +251,10 @@ module QuestDB
       end
     end
 
+    def ensure_durable_ack!(ack_level)
+      Config.ensure_durable_ack!(@durable_ack_requested, ack_level, PooledSender::ACK_LEVELS[:durable])
+    end
+
     def ensure_open!
       raise Ingress::IngressError.new("client is closed", code: :invalid_api_call) if closed?
     end

data/lib/questdb/config.rb

@@ -117,6 +117,25 @@ module QuestDB
       parts
     end
 
+    # Whether request_durable_ack asks for durable ACKs. Only the absent and
+    # explicit off values are recognised, so future tier values pass through
+    # to the native client unchanged.
+    def durable_ack_requested?(settings)
+      value = settings["request_durable_ack"]
+      !value.nil? && !value.to_s.strip.match?(/\A(?:off|false)\z/i)
+    end
+
+    # Fails before anything is sent when ack: :durable can never succeed,
+    # instead of after a direct batch or a row frame was already published.
+    def ensure_durable_ack!(requested, ack_level, durable_level)
+      return if requested || ack_level != durable_level
+
+      raise Ingress::IngressError.new(
+        "ack: :durable requires request_durable_ack=on in the configuration; nothing was sent",
+        code: :invalid_api_call
+      )
+    end
+
     def setting_value(value, key = nil)
       if key&.to_sym == :tls_verify && value == false
         "unsafe_off"

data/lib/questdb/pooled_sender.rb

@@ -61,6 +61,7 @@ module QuestDB
       ensure_open!
       level = normalize_ack(ack)
       raise ArgumentError, "ack: :durable requires wait: true" if level == ACK_LEVELS[:durable] && !wait
+      @client.send(:ensure_durable_ack!, level)
       return self if empty? && !wait
       @native.flush(@buffer.send(:native), !!wait, level)
       @batch_started = nil if @buffer.empty?
@@ -70,7 +71,9 @@ module QuestDB
     def wait(timeout_millis: 0, ack: :ok)
       ensure_open!
       timeout = non_negative_integer(timeout_millis, "timeout_millis")
-      @native.wait(normalize_ack(ack), timeout)
+      level = normalize_ack(ack)
+      @client.send(:ensure_durable_ack!, level)
+      @native.wait(level, timeout)
       self
     end
 

data/lib/questdb/sender.rb

@@ -121,6 +121,7 @@ module QuestDB
         max_rows_per_batch: max_rows_per_batch, ack: ack
       )
       ensure_ws!
+      ensure_durable_ack!(prepared[6])
       return self if prepared[4].zero?
       @native.ingest_columns(@configuration, *prepared)
       self
@@ -142,6 +143,7 @@ module QuestDB
       raise ArgumentError, "clear: false requires an explicit buffer" if target.equal?(@buffer) && !clear
       level = normalize_ack(ack)
       raise ArgumentError, "ack: :durable requires wait: true" if level == ACK_LEVELS[:durable] && !wait
+      ensure_durable_ack!(level)
       return self if target.empty? && !wait
       @native.flush(target.send(:native), !clear)
       @native.wait(level, 0) if wait
@@ -151,7 +153,9 @@ module QuestDB
 
     def wait(timeout_millis: 0, ack: :ok)
       ensure_ws!
-      @native.wait(normalize_ack(ack), non_negative_integer(timeout_millis, "timeout_millis"))
+      level = normalize_ack(ack)
+      ensure_durable_ack!(level)
+      @native.wait(level, non_negative_integer(timeout_millis, "timeout_millis"))
       self
     end
 
@@ -339,6 +343,7 @@ module QuestDB
       @dispatcher_threads = []
       @native = @buffer = nil
       @closed = false
+      @durable_ack_requested = Config.durable_ack_requested?(settings)
       @init_buf_size = Integer(settings.fetch("init_buf_size", 65_536))
       raise ArgumentError, "init_buf_size must be nonnegative" if @init_buf_size.negative?
       raise RangeError, "init_buf_size exceeds 100 MiB" if @init_buf_size > Ingress::Buffer::MAX_PREALLOCATE_BYTES
@@ -394,6 +399,10 @@ module QuestDB
       true
     end
 
+    def ensure_durable_ack!(ack_level)
+      Config.ensure_durable_ack!(@durable_ack_requested, ack_level, ACK_LEVELS[:durable])
+    end
+
     def normalize_ack(value)
       value = value.to_sym if value.respond_to?(:to_sym)
       ACK_LEVELS.fetch(value) { raise ArgumentError, "ack must be :ok or :durable" }

data/lib/questdb/version.rb

@@ -21,7 +21,7 @@
 #
 module QuestDB
   module Ingress
-    VERSION = "0.1.0"
-    C_CLIENT_VERSION = "7.1.0"
+    VERSION = "0.1.1"
+    C_CLIENT_VERSION = "7.2.0"
   end
 end

data/script/check-native-linkage

@@ -0,0 +1,115 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#      ___                  _   ____  ____
+#     / _ \ _   _  ___  ___| |_|  _ \| __ )
+#    | | | | | | |/ _ \/ __| __| | | |  _ \
+#    | |_| | |_| |  __/\__ \ |_| |_| | |_) |
+#     \__\_\\__,_|\___||___/\__|____/|____/
+#
+#   Copyright (c) 2014-2019 Appsicle
+#   Copyright (c) 2019-2026 QuestDB
+#
+#   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.
+#
+
+# Fails when a native extension is linked to the Ruby that built it. Such an
+# extension loads on the build machine but not on a user's Ruby, so an install
+# test on the build machine cannot catch it. Reads ELF and Mach-O headers
+# directly; PE (Windows) extensions must import the Ruby DLL and are skipped.
+#
+#   script/check-native-linkage lib/questdb/native/*/questdb_ingress.{so,bundle}
+
+def elf_needed(bytes)
+  raise "32-bit ELF is not supported" unless bytes.getbyte(4) == 2
+  le = bytes.getbyte(5) == 1
+  q = le ? "Q<" : "Q>"
+  l = le ? "L<" : "L>"
+  s = le ? "S<" : "S>"
+  shoff = bytes.unpack1(q, offset: 0x28)
+  shentsize, shnum = bytes.unpack("#{s}#{s}", offset: 0x3a)
+  sections = Array.new(shnum) do |i|
+    base = shoff + i * shentsize
+    { type: bytes.unpack1(l, offset: base + 4), offset: bytes.unpack1(q, offset: base + 0x18),
+      size: bytes.unpack1(q, offset: base + 0x20), link: bytes.unpack1(l, offset: base + 0x28) }
+  end
+  dynamic = sections.find { |sec| sec[:type] == 6 } or return []
+  strtab = sections.fetch(dynamic[:link])
+  (0...dynamic[:size] / 16).filter_map do |i|
+    tag, val = bytes.unpack("#{q}#{q}", offset: dynamic[:offset] + i * 16)
+    next unless tag == 1 # DT_NEEDED
+
+    bytes.byteslice(strtab[:offset] + val, 256).unpack1("Z*")
+  end
+end
+
+def macho(bytes)
+  raise "only 64-bit little-endian Mach-O is supported" unless bytes.unpack1("L<") == 0xfeedfacf
+
+  ncmds = bytes.unpack1("L<", offset: 16)
+  offset = 32
+  dylibs = []
+  symtab = nil
+  ncmds.times do
+    cmd, size = bytes.unpack("L<L<", offset: offset)
+    case cmd
+    when 0xc, 0x80000018, 0x8000001f # LC_LOAD_DYLIB, LC_LOAD_WEAK_DYLIB, LC_REEXPORT_DYLIB
+      dylibs << bytes.byteslice(offset + bytes.unpack1("L<", offset: offset + 8), size).unpack1("Z*")
+    when 0x2 # LC_SYMTAB
+      symtab = bytes.unpack("L<L<L<", offset: offset + 8)
+    end
+    offset += size
+  end
+  bound_to_executable = []
+  if symtab
+    symoff, nsyms, stroff = symtab
+    nsyms.times do |i|
+      strx, type, _sect, desc = bytes.unpack("L<CCS<", offset: symoff + i * 16)
+      next unless (type & 0x0e).zero? && (type & 1) == 1 # undefined external
+
+      name = bytes.byteslice(stroff + strx, 256).unpack1("Z*")
+      bound_to_executable << name if ((desc >> 8) & 0xff) == 0xff # EXECUTABLE_ORDINAL
+    end
+  end
+  [dylibs, bound_to_executable]
+end
+
+abort "usage: #{$PROGRAM_NAME} EXTENSION..." if ARGV.empty?
+
+failures = []
+ARGV.each do |path|
+  bytes = File.binread(path)
+  if bytes.start_with?("\x7FELF".b)
+    libruby = elf_needed(bytes).grep(/libruby/)
+    failures << "#{path}: links #{libruby.join(', ')}" unless libruby.empty?
+  elsif bytes.unpack1("L<") == 0xfeedfacf
+    dylibs, executable = macho(bytes)
+    pinned = dylibs.grep(%r{libruby|/Users/|hostedtoolcache})
+    failures << "#{path}: links #{pinned.join(', ')}" unless pinned.empty?
+    unless executable.empty?
+      failures << "#{path}: #{executable.size} symbols bound to the build Ruby executable " \
+                  "(e.g. #{executable.first}); link with -undefined dynamic_lookup"
+    end
+  elsif bytes.start_with?("MZ".b)
+    next
+  else
+    failures << "#{path}: unrecognized binary format"
+  end
+end
+
+if failures.empty?
+  puts "native linkage ok: #{ARGV.size} extension(s) resolve Ruby's C API at load time"
+else
+  warn failures
+  exit 1
+end

data/test/client_test.rb

@@ -35,6 +35,36 @@ class ClientTest < Minitest::Test
     assert_raises(RangeError) { QuestDB.connect(host: "localhost", port: 0) }
   end
 
+  # ack: :durable without request_durable_ack can never succeed. It must fail
+  # before anything is sent: the unreachable address makes any borrow or
+  # connect attempt raise :socket_error instead.
+  def test_durable_ack_without_opt_in_fails_before_sending
+    fast = LAZY_CONF + "reconnect_max_duration_millis=1;"
+    [fast, fast + "request_durable_ack=off;"].each do |conf|
+      client = QuestDB.connect(conf)
+      [
+        -> { client.ingest_columns("t", columns: { v: [1] }, at: QuestDB::SERVER_TIMESTAMP, ack: :durable) },
+        -> { client.sender { |s| s.row("t", columns: { v: 1 }, at: QuestDB::SERVER_TIMESTAMP); s.flush(wait: true, ack: :durable) } },
+        -> { client.sender { |s| s.wait(ack: :durable) } }
+      ].each do |call|
+        error = assert_raises(IngressError) { call.call }
+        assert_equal :invalid_api_call, error.code, error.message
+        refute error.in_doubt?, error.message
+        assert_match(/request_durable_ack/, error.message)
+      end
+      client.close
+    end
+  end
+
+  def test_durable_ack_opt_in_is_not_rejected_up_front
+    client = QuestDB.connect(LAZY_CONF + "reconnect_max_duration_millis=1;request_durable_ack=on;")
+    error = assert_raises(IngressError) do
+      client.ingest_columns("t", columns: { v: [1] }, at: QuestDB::SERVER_TIMESTAMP, ack: :durable)
+    end
+    refute_match(/request_durable_ack/, error.message, "an opted-in client must reach the network")
+    client.close
+  end
+
   def test_config_builder_ipv6_escaping_and_duplicates
     conf, = QuestDB::Config.build(host: "::1", port: 9000, tls: true,
                                   settings: { username: "a;b", lazy_connect: true })