b4n1-boost 0.4.2 → 0.4.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7781402242b38972d803ea940c41f33d7eb2c5ddd90c59e1feae132231af6b94
-  data.tar.gz: a993c57fdd0facfb21bea698327471063fc0da58cc3889b3fb305aeb53abd1ea
+  metadata.gz: b2f63ef0c8953fa639cb8ca11d1a9892c75dabcabd90519e13e0858934ae5448
+  data.tar.gz: b16352e42cbd457dc10a4dedcba692c3b08f3d997fe16bfa472f554ca1946389
 SHA512:
-  metadata.gz: f9e8bba9eee9abc810d193b8143da2efe57031e0b3e24238057a3c665e59c7030828d23f1f4163d6c9e2b709a0ec401ac7462157c72d1955afffd1905b501dce
-  data.tar.gz: f0fa7a531b88493ee7fd89b36de6339edf19463b67c9e53a5c4f5426f1f5a87148ad41c68c2978b0c089806d6c41a5fac5a2c739b39c3e5d7706843c72830262
+  metadata.gz: 7e43fbdd59218e909db7ba8e184f682dad1955bb71c4f31d62e3c2690e58f87fad743bb4a0b7d547d8f05a492446888e9c209a25831f6e738d4ca9e9a7f36297
+  data.tar.gz: 48d53e75e0397aed2472d07382b60d6bab26c61db8acd6d91025ccb4adf091ecf09f5d14cbb12cdd4710bdc6e7f4a8ce110bd85c48118dd1bdcca73e900eb442

data/core.rb

@@ -0,0 +1,143 @@
+# B4N1-Boost Ruby SDK — core primitives: response cache, bloom filter,
+# circuit breaker. Business Source License 1.1 (BUSL-1.1).
+# Thin FFI wrapper over the proprietary B4N1 native core. ALL logic (LRU
+# eviction, TTL, bloom hashing, circuit thresholds) lives in the native core
+# and is shared with Python, Node.js, .NET and Java through the same C-ABI —
+# a fix in the core fixes every SDK at once.
+# The native binary is licensed separately under the B4N1 EULA (EULA.txt).
+# Copyright (c) 2026 B4N1. All rights reserved.
+require_relative 'boost'
+
+module B4N1
+  module Boost
+    extern 'uint64_t b4n1_cache_new(int)'
+    extern 'int b4n1_cache_get(uint64_t, char*, void**, size_t*, uint16_t*)'
+    extern 'int b4n1_cache_set(uint64_t, char*, char*, size_t, uint16_t, uint64_t)'
+    extern 'int b4n1_cache_invalidate(uint64_t, char*)'
+    extern 'void b4n1_cache_clear(uint64_t)'
+    extern 'void b4n1_cache_free(uint64_t)'
+    extern 'uint64_t b4n1_bloom_new(uint64_t, uint64_t)'
+    extern 'int b4n1_bloom_check_and_set(uint64_t, char*)'
+    extern 'void b4n1_bloom_free(uint64_t)'
+    extern 'uint64_t b4n1_circuit_new(int, int, uint64_t)'
+    extern 'int b4n1_circuit_allows(uint64_t)'
+    extern 'void b4n1_circuit_record_success(uint64_t)'
+    extern 'void b4n1_circuit_record_failure(uint64_t)'
+    extern 'void b4n1_circuit_free(uint64_t)'
+
+    # Response cache (LRU + TTL) backed by the native core.
+    #
+    #   cache = B4N1::Boost::ResponseCache.new(1024)
+    #   cache.set('user:1', body, 200, 60)   # ttl_secs 0 = never expires
+    #   hit  = cache.get('user:1')           # => { body:, status: } or nil
+    #   hit[:body]                            # binary-safe String
+    class ResponseCache
+      def initialize(capacity = 1024)
+        @handle = Boost.b4n1_cache_new(capacity)
+        raise ArgumentError, 'Response cache capacity out of bounds (max 1_000_000)' if @handle.zero?
+
+        @handle
+      end
+
+      # Returns { body:, status: } on a hit, nil on a miss.
+      def get(key)
+        out_ptr = Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP)
+        out_len = Fiddle::Pointer.malloc(Fiddle::SIZEOF_SIZE_T)
+        out_status = Fiddle::Pointer.malloc(2)
+        return nil unless Boost.b4n1_cache_get(@handle, key, out_ptr, out_len, out_status) == 1
+
+        addr = out_ptr[0, Fiddle::SIZEOF_VOIDP].unpack1('J')
+        len = out_len[0, Fiddle::SIZEOF_SIZE_T].unpack1('J')
+        # Copy before releasing: the core owns that buffer.
+        body = Fiddle::Pointer.new(addr).to_str(len)
+        Boost.b4n1_boost_free_buffer(Fiddle::Pointer.new(addr), len)
+        { body: body, status: out_status[0, 2].unpack1('S') }
+      end
+
+      # ttl_secs == 0 means never expires (core semantics, matches Node).
+      def set(key, body, status = 200, ttl_secs = 300)
+        bytes = body.to_s.b
+        rc = Boost.b4n1_cache_set(@handle, key, bytes.empty? ? nil : bytes, bytes.bytesize, status, ttl_secs)
+        raise 'Response cache set failed (stale handle?)' unless rc.zero?
+      end
+
+      # Returns true when the key existed and was removed.
+      def invalidate(key)
+        Boost.b4n1_cache_invalidate(@handle, key) == 1
+      end
+
+      def clear
+        Boost.b4n1_cache_clear(@handle)
+      end
+
+      def close
+        return if @handle.nil? || @handle.zero?
+
+        Boost.b4n1_cache_free(@handle)
+        @handle = 0
+      end
+    end
+
+    # Bloom filter for rate limiting / dedup.
+    #
+    #   seen = B4N1::Boost::BloomFilter.new(100_000, 0.01)
+    #   seen.check_and_set('req-1')  # => false (first time, now recorded)
+    #   seen.check_and_set('req-1')  # => true  (duplicate)
+    class BloomFilter
+      def initialize(expected_items = 10_000, fp_rate = 0.01)
+        # The core reads the double from its u64 bit pattern.
+        bits = [fp_rate.to_f].pack('d').unpack1('Q')
+        @handle = Boost.b4n1_bloom_new(expected_items, bits)
+        raise ArgumentError, 'Bloom expected items out of bounds (max 10_000_000)' if @handle.zero?
+      end
+
+      # Returns true when the item was already present (duplicate).
+      def check_and_set(item)
+        Boost.b4n1_bloom_check_and_set(@handle, item) == 1
+      end
+
+      def close
+        return if @handle.nil? || @handle.zero?
+
+        Boost.b4n1_bloom_free(@handle)
+        @handle = 0
+      end
+    end
+
+    # Circuit breaker: allows? is false while the circuit is open.
+    #
+    #   breaker = B4N1::Boost::CircuitBreaker.new(5, 2, 30)
+    #   fallback unless breaker.allows?
+    #   breaker.record_failure  # or record_success after a good call
+    class CircuitBreaker
+      def initialize(threshold = 5, success_threshold = 1, timeout_secs = 30)
+        @handle = Boost.b4n1_circuit_new(threshold, success_threshold, timeout_secs)
+        raise 'Circuit breaker handle invalid' if @handle.zero?
+      end
+
+      # Returns false when calls must NOT go through (circuit open, or the
+      # breaker was closed — a closed breaker must fail CLOSED, never
+      # resurrect through the C-ABI's 0-handle legacy path).
+      def allows?
+        return false if @handle.nil? || @handle.zero?
+
+        Boost.b4n1_circuit_allows(@handle) == 1
+      end
+
+      def record_success
+        Boost.b4n1_circuit_record_success(@handle)
+      end
+
+      def record_failure
+        Boost.b4n1_circuit_record_failure(@handle)
+      end
+
+      def close
+        return if @handle.nil? || @handle.zero?
+
+        Boost.b4n1_circuit_free(@handle)
+        @handle = 0
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: b4n1-boost
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.4.4
 platform: ruby
 authors:
 - B4N1 Team
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-23 00:00:00.000000000 Z
+date: 2026-11-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -36,6 +36,7 @@ files:
 - LICENSE
 - README.md
 - boost.rb
+- core.rb
 - lib/native/linux-arm64/libb4n1_boost.so
 - lib/native/linux-x64/libb4n1_boost.so
 - lib/native/macos-arm64/libb4n1_boost.dylib
@@ -46,7 +47,7 @@ homepage: https://github.com/B4N1-com/private-repos
 licenses:
 - BUSL-1.1
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - "."
@@ -61,8 +62,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.5
-signing_key: 
+rubygems_version: 3.4.20
+signing_key:
 specification_version: 4
 summary: High-performance native Rust boost layer for Ruby & Rack/Rails.
 test_files: []