rdkafka 0.29.1-aarch64-linux-gnu → 0.30.0-aarch64-linux-gnu

data/lib/rdkafka/callbacks.rb

@@ -21,10 +21,9 @@ module Rdkafka
       # @param array_pointer [FFI::Pointer] pointer to the results array
       # @return [Array<TopicResult>] array of topic results
       def self.create_topic_results_from_array(count, array_pointer)
-        (1..count).map do |index|
-          result_pointer = (array_pointer + (index - 1)).read_pointer
-          new(result_pointer)
-        end
+        return [] if count.zero?
+
+        array_pointer.read_array_of_pointer(count).map { |result_pointer| new(result_pointer) }
       end
     end
 
@@ -53,10 +52,9 @@ module Rdkafka
       # @param array_pointer [FFI::Pointer] pointer to the results array
       # @return [Array<GroupResult>] array of group results
       def self.create_group_results_from_array(count, array_pointer)
-        (1..count).map do |index|
-          result_pointer = (array_pointer + (index - 1)).read_pointer
-          new(result_pointer)
-        end
+        return [] if count.zero?
+
+        array_pointer.read_array_of_pointer(count).map { |result_pointer| new(result_pointer) }
       end
     end
 
@@ -77,10 +75,9 @@ module Rdkafka
       # @param array_pointer [FFI::Pointer] pointer to the results array
       # @return [Array<CreateAclResult>] array of ACL results
       def self.create_acl_results_from_array(count, array_pointer)
-        (1..count).map do |index|
-          result_pointer = (array_pointer + (index - 1)).read_pointer
-          new(result_pointer)
-        end
+        return [] if count.zero?
+
+        array_pointer.read_array_of_pointer(count).map { |result_pointer| new(result_pointer) }
       end
     end
 
@@ -108,10 +105,9 @@ module Rdkafka
       # @param array_pointer [FFI::Pointer] pointer to the results array
       # @return [Array<DeleteAclResult>] array of delete ACL results
       def self.delete_acl_results_from_array(count, array_pointer)
-        (1..count).map do |index|
-          result_pointer = (array_pointer + (index - 1)).read_pointer
-          new(result_pointer)
-        end
+        return [] if count.zero?
+
+        array_pointer.read_array_of_pointer(count).map { |result_pointer| new(result_pointer) }
       end
     end
 
@@ -213,6 +209,8 @@ module Rdkafka
         when Rdkafka::Bindings::RD_KAFKA_EVENT_DELETETOPICS_RESULT then DeleteTopicHandler
         when Rdkafka::Bindings::RD_KAFKA_ADMIN_OP_CREATEPARTITIONS_RESULT then CreatePartitionsHandler
         when Rdkafka::Bindings::RD_KAFKA_EVENT_DELETEGROUPS_RESULT then DeleteGroupsHandler
+        when Rdkafka::Bindings::RD_KAFKA_EVENT_ALTERCONSUMERGROUPOFFSETS_RESULT then AlterConsumerGroupOffsetsHandler
+        when Rdkafka::Bindings::RD_KAFKA_EVENT_DELETECONSUMERGROUPOFFSETS_RESULT then DeleteConsumerGroupOffsetsHandler
         when Rdkafka::Bindings::RD_KAFKA_EVENT_DELETERECORDS_RESULT then DeleteRecordsHandler
         when Rdkafka::Bindings::RD_KAFKA_EVENT_CREATEACLS_RESULT then CreateAclHandler
         when Rdkafka::Bindings::RD_KAFKA_EVENT_DELETEACLS_RESULT then DeleteAclHandler

data/lib/rdkafka/clients.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  # Tracks live public clients so they can be closed before Ruby begins forced finalization.
+  # @private
+  module Clients
+    # Ruby rewrote `ObjectSpace::WeakMap` in 3.3. On 3.2 and earlier its `[]` can hand back a
+    # foreign or already-freed object for a key, which raises `NoMethodError` or segfaults the VM
+    # the moment the value is touched. Track weakly only where that is safe and fall back to a
+    # strong registry - pruned as clients close - on older Rubies. The strong registry holds an
+    # open, un-closed client until shutdown, which is exactly when this cleanup needs it anyway.
+    WEAK_TRACKING = Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("3.3")
+
+    @pid = Process.pid
+    @mutex = Mutex.new
+
+    if WEAK_TRACKING
+      @clients = ObjectSpace::WeakMap.new
+      @tokens = [].freeze
+    else
+      @clients = {}.freeze
+    end
+
+    # Registers a successfully constructed client so it can be closed during process shutdown.
+    # @param client [Consumer, Producer, Admin] client to close during process shutdown
+    # @return [Consumer, Producer, Admin] the registered client
+    def self.register(client)
+      reset_after_fork
+
+      @mutex.synchronize do
+        if WEAK_TRACKING
+          live_clients
+
+          # The strongly-held token is the key and the client is the weak value, so registering a
+          # client never keeps it alive. Enumerating weak keys can expose reclaimed slots, so we
+          # look the value up by token instead.
+          token = Object.new
+          @clients[token] = client
+          @tokens = (@tokens + [token]).freeze
+        else
+          # Strong references, so drop clients that have already been closed to bound growth.
+          live = @clients.reject { |_id, existing| existing.closed? }
+          live[client.object_id] = client
+          @clients = live.freeze
+        end
+      end
+
+      client
+    end
+
+    # Closes each live client registered in this process.
+    # @return [nil]
+    # @raise [StandardError] the first close error, after attempting every client
+    def self.close_all
+      return unless @pid == Process.pid
+
+      clients = @mutex.synchronize { current_clients }
+      first_error = nil
+
+      clients.each do |client|
+        client.close unless client.closed?
+      rescue => error
+        first_error ||= error
+      end
+
+      raise first_error if first_error
+    end
+
+    # Returns the currently registered live clients.
+    # @return [Array<Consumer, Producer, Admin>] live clients
+    # @private
+    def self.current_clients
+      WEAK_TRACKING ? live_clients : @clients.values
+    end
+    private_class_method :current_clients
+
+    # Returns the live clients and releases tokens whose clients have been collected.
+    # Weak-tracking Rubies only.
+    # @return [Array<Consumer, Producer, Admin>] live clients
+    # @private
+    def self.live_clients
+      clients = []
+      tokens = []
+
+      @tokens.each do |token|
+        client = @clients[token]
+        clients << client if client
+        tokens << token if client
+      end
+
+      @tokens = tokens.freeze
+      clients
+    end
+    private_class_method :live_clients
+
+    # Replaces inherited state before registering a client in a forked child.
+    # @return [nil]
+    # @private
+    def self.reset_after_fork
+      return if @pid == Process.pid
+
+      if WEAK_TRACKING
+        @clients = ObjectSpace::WeakMap.new
+        @tokens = [].freeze
+      else
+        @clients = {}.freeze
+      end
+
+      @pid = Process.pid
+      @mutex = Mutex.new
+    end
+    private_class_method :reset_after_fork
+  end
+end

data/lib/rdkafka/config.rb

@@ -22,6 +22,12 @@ module Rdkafka
     @@log_mutex = Mutex.new
     # @!visibility private
     @@oauthbearer_token_refresh_callback = nil
+    # @!visibility private
+    # Whether the partition key length passed to the partitioner is the byte length (`bytesize`)
+    # rather than the character length (`size`). `false` (character length) is the legacy default
+    # to avoid changing partition assignment for existing multibyte/binary keys; set to `true` to
+    # opt into the correct, other-client-consistent byte-length hashing.
+    @@partitioner_key_uses_bytesize = false
 
     # Returns the current logger, by default this is a logger to stdout.
     #
@@ -122,6 +128,34 @@ module Rdkafka
       @@oauthbearer_token_refresh_callback
     end
 
+    # Whether the partitioner hashes the partition key by its byte length instead of its character
+    # length. Defaults to `false` (character length) to preserve existing partition assignment for
+    # multibyte/binary keys. Passing the byte length is the correct, other-client-consistent
+    # behavior; enable it (and be aware it can move such keys to a different partition) with
+    # `Rdkafka::Config.partitioner_key_uses_bytesize = true`. This default is expected to change in
+    # a future major version.
+    #
+    # @return [Boolean]
+    def self.partitioner_key_uses_bytesize
+      @@partitioner_key_uses_bytesize
+    end
+
+    # Sets whether the partitioner hashes the partition key by its byte length rather than its
+    # character length. The key length method is resolved here once rather than on every produced
+    # message, and each call re-resolves it, so changing the setting at runtime takes effect
+    # immediately.
+    #
+    # @param value [Boolean] true to hash by byte length, false (default) for character length
+    # @return [void]
+    def self.partitioner_key_uses_bytesize=(value)
+      @@partitioner_key_uses_bytesize = value
+
+      Rdkafka::Bindings.singleton_class.alias_method(
+        :partition_key_length,
+        value ? :partition_key_bytesize : :partition_key_size
+      )
+    end
+
     # @private
     def self.opaques
       @@opaques
@@ -209,21 +243,16 @@ module Rdkafka
         Rdkafka::Bindings.rd_kafka_conf_set_rebalance_cb(config, Rdkafka::Bindings::RebalanceCallback)
       end
 
-      # Create native client
-      kafka = native_kafka(config, :rd_kafka_consumer)
-
-      # Redirect the main queue to the consumer queue
-      Rdkafka::Bindings.rd_kafka_poll_set_consumer(kafka) if @consumer_poll_set
-
-      # Return consumer with Kafka client
-      Rdkafka::Consumer.new(
-        Rdkafka::NativeKafka.new(
-          kafka,
-          run_polling_thread: false,
-          opaque: opaque,
-          auto_start: native_kafka_auto_start
-        )
-      )
+      build_native_client(
+        config,
+        :rd_kafka_consumer,
+        opaque: opaque,
+        run_polling_thread: false,
+        auto_start: native_kafka_auto_start
+      ) do |kafka, native_kafka|
+        Rdkafka::Bindings.rd_kafka_poll_set_consumer(kafka) if @consumer_poll_set
+        Rdkafka::Consumer.new(native_kafka)
+      end
     end
 
     # Create a producer with this configuration.
@@ -247,19 +276,17 @@ module Rdkafka
       # Return producer with Kafka client
       partitioner_name = self[:partitioner] || self["partitioner"]
 
-      kafka = native_kafka(config, :rd_kafka_producer)
-
-      Rdkafka::Producer.new(
-        Rdkafka::NativeKafka.new(
-          kafka,
-          run_polling_thread: run_polling_thread,
-          opaque: opaque,
-          auto_start: native_kafka_auto_start,
-          timeout_ms: native_kafka_poll_timeout_ms
-        ),
-        partitioner_name
-      ).tap do |producer|
-        opaque.producer = producer
+      build_native_client(
+        config,
+        :rd_kafka_producer,
+        opaque: opaque,
+        run_polling_thread: run_polling_thread,
+        auto_start: native_kafka_auto_start,
+        timeout_ms: native_kafka_poll_timeout_ms
+      ) do |_kafka, native_kafka|
+        Rdkafka::Producer.new(native_kafka, partitioner_name).tap do |producer|
+          opaque.producer = producer
+        end
       end
     end
 
@@ -279,17 +306,16 @@ module Rdkafka
       config = native_config(opaque)
       Rdkafka::Bindings.rd_kafka_conf_set_background_event_cb(config, Rdkafka::Callbacks::BackgroundEventCallbackFunction)
 
-      kafka = native_kafka(config, :rd_kafka_producer)
-
-      Rdkafka::Admin.new(
-        Rdkafka::NativeKafka.new(
-          kafka,
-          run_polling_thread: run_polling_thread,
-          opaque: opaque,
-          auto_start: native_kafka_auto_start,
-          timeout_ms: native_kafka_poll_timeout_ms
-        )
-      )
+      build_native_client(
+        config,
+        :rd_kafka_producer,
+        opaque: opaque,
+        run_polling_thread: run_polling_thread,
+        auto_start: native_kafka_auto_start,
+        timeout_ms: native_kafka_poll_timeout_ms
+      ) do |_kafka, native_kafka|
+        Rdkafka::Admin.new(native_kafka)
+      end
     end
 
     # Returns all configuration properties and their current values for this config.
@@ -343,6 +369,56 @@ module Rdkafka
 
     private
 
+    # Builds a public client around a native Kafka handle, destroying the current owner if setup
+    # fails before ownership is transferred to the caller.
+    # @param config [FFI::Pointer] native rdkafka configuration
+    # @param type [Symbol] native client type
+    # @param opaque [Object] callback context retained for the native client
+    # @param run_polling_thread [Boolean] whether to run a Ruby polling thread
+    # @param auto_start [Boolean] whether to start the polling thread after wrapping the client
+    # @param timeout_ms [Integer] polling timeout in milliseconds
+    # @yieldparam kafka [FFI::Pointer] native Kafka handle
+    # @yieldparam native_kafka [NativeKafka] Ruby owner of the native handle
+    # @return [Consumer, Producer, Admin] the constructed public client
+    # @private
+    def build_native_client(
+      config,
+      type,
+      opaque:,
+      run_polling_thread:,
+      auto_start:,
+      timeout_ms: Defaults::NATIVE_KAFKA_POLL_TIMEOUT_MS
+    )
+      kafka = native_kafka(config, type)
+      native_kafka = nil
+      client = nil
+
+      begin
+        native_kafka = Rdkafka::NativeKafka.new(
+          kafka,
+          run_polling_thread: run_polling_thread,
+          opaque: opaque,
+          auto_start: false,
+          timeout_ms: timeout_ms
+        )
+        client = yield(kafka, native_kafka)
+        native_kafka.start if auto_start
+        Rdkafka::Clients.register(client)
+      rescue Exception
+        owner = client || native_kafka
+
+        begin
+          owner ? owner.close : Rdkafka::Bindings.rd_kafka_destroy(kafka)
+        rescue Exception => err
+          # Never let a teardown failure replace the error that caused it: that error is what the
+          # caller needs to see, and it is re-raised below regardless.
+          Rdkafka::Config.logger.error("Unhandled exception: #{err.class} - #{err.message}")
+        end
+
+        raise
+      end
+    end
+
     # This method is only intended to be used to create a client,
     # using it in another way will leak memory.
     #
@@ -429,6 +505,9 @@ module Rdkafka
 
       # Return handle which should be closed using rd_kafka_destroy after usage.
       handle
+    rescue Exception
+      Rdkafka::Bindings.rd_kafka_destroy(handle) if handle && !handle.null?
+      raise
     end
   end
 

data/lib/rdkafka/consumer/allocator.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  class Consumer
+    # Creates FFI pointers from the process-global allocator so that memory handed to librdkafka
+    # can be released by it with the matching `free`.
+    module Allocator
+      extend FFI::Library
+
+      ffi_lib FFI::CURRENT_PROCESS # use process-global malloc not FFI::Library::LIBC
+      attach_function :malloc, [:size_t], :pointer
+
+      class << self
+        # Return an FFI pointer to a string allocated from the global allocator
+        # so that it can be released by another library.
+        #
+        # @private
+        #
+        # @param string [String] Ruby string that will be copied into the new
+        #   string pointer.
+        #
+        # @return [FFI::Pointer]
+        def string_pointer(string)
+          bytes = string.to_s
+          pointer = malloc(bytes.bytesize + 1)
+          Kernel.raise(NoMemoryError, "malloc failed") if pointer.null?
+
+          pointer.put_bytes(0, bytes)
+          pointer.put_char(bytes.bytesize, 0) # NUL terminator
+
+          pointer.autorelease = false
+
+          pointer
+        end
+      end
+    end
+  end
+end

data/lib/rdkafka/consumer/topic_partition_list.rb

@@ -160,10 +160,9 @@ module Rdkafka
 
                 if p.metadata
                   part = Rdkafka::Bindings::TopicPartition.new(ref)
-                  str_ptr = FFI::MemoryPointer.from_string(p.metadata)
                   # The metadata string is owned by librdkafka once handed over and released here:
                   # https://github.com/confluentinc/librdkafka/blob/e03d3bb91ed92a38f38d9806b8d8deffe78a1de5/src/rdkafka_partition.c#L2682C18-L2682C18
-                  str_ptr.autorelease = false
+                  str_ptr = Allocator.string_pointer(p.metadata)
                   part[:metadata] = str_ptr
                   part[:metadata_size] = p.metadata.bytesize
                 end

data/lib/rdkafka/consumer.rb

@@ -916,33 +916,35 @@ module Rdkafka
       begin
         while i < count
           ptr = buffer.get_pointer(i * FFI::Pointer.size)
+          # Take ownership of this index before processing the pointer: advancing `i` up front means
+          # the cleanup loop in the `ensure` below starts past it, so a raise mid-iteration cannot
+          # double-free the same message.
+          i += 1
 
-          if ptr.null?
-            i += 1
-            next
-          end
+          next if ptr.null?
 
-          native_message = Rdkafka::Bindings::Message.new(ptr)
+          # One `ensure` around the whole body guarantees `ptr` is destroyed exactly once on every
+          # path - the error branch, a successful build, a rescued `RdkafkaError`, or any other
+          # exception unwinding through here - so nothing leaks in the window before the build.
+          begin
+            native_message = Rdkafka::Bindings::Message.new(ptr)
 
-          if native_message[:err] != Rdkafka::Bindings::RD_KAFKA_RESP_ERR_NO_ERROR
-            results << Rdkafka::RdkafkaError.new(native_message[:err])
-            Rdkafka::Bindings.rd_kafka_message_destroy(ptr)
-            i += 1
-            next
-          end
+            if native_message[:err] != Rdkafka::Bindings::RD_KAFKA_RESP_ERR_NO_ERROR
+              results << Rdkafka::RdkafkaError.new(native_message[:err])
+              next
+            end
 
-          begin
-            results << Rdkafka::Consumer::Message.new(native_message)
-          rescue Rdkafka::RdkafkaError => e
-            # A message that fails to build (e.g. a header read error) is surfaced inline as an
-            # error event rather than discarding the whole batch - including the messages already
-            # built - and raising, which silently lost them once their offsets had been stored.
-            results << e
+            begin
+              results << Rdkafka::Consumer::Message.new(native_message)
+            rescue Rdkafka::RdkafkaError => e
+              # A message that fails to build (e.g. a header read error) is surfaced inline as an
+              # error event rather than discarding the whole batch - including the messages already
+              # built - and raising, which silently lost them once their offsets had been stored.
+              results << e
+            end
           ensure
             Rdkafka::Bindings.rd_kafka_message_destroy(ptr)
           end
-
-          i += 1
         end
       ensure
         while i < count
@@ -991,33 +993,35 @@ module Rdkafka
       begin
         while i < count
           ptr = buffer.get_pointer(i * FFI::Pointer.size)
+          # Take ownership of this index before processing the pointer: advancing `i` up front means
+          # the cleanup loop in the `ensure` below starts past it, so a raise mid-iteration cannot
+          # double-free the same message.
+          i += 1
 
-          if ptr.null?
-            i += 1
-            next
-          end
+          next if ptr.null?
 
-          native_message = Rdkafka::Bindings::Message.new(ptr)
+          # One `ensure` around the whole body guarantees `ptr` is destroyed exactly once on every
+          # path - the error branch, a successful build, a rescued `RdkafkaError`, or any other
+          # exception unwinding through here - so nothing leaks in the window before the build.
+          begin
+            native_message = Rdkafka::Bindings::Message.new(ptr)
 
-          if native_message[:err] != Rdkafka::Bindings::RD_KAFKA_RESP_ERR_NO_ERROR
-            results << Rdkafka::RdkafkaError.new(native_message[:err])
-            Rdkafka::Bindings.rd_kafka_message_destroy(ptr)
-            i += 1
-            next
-          end
+            if native_message[:err] != Rdkafka::Bindings::RD_KAFKA_RESP_ERR_NO_ERROR
+              results << Rdkafka::RdkafkaError.new(native_message[:err])
+              next
+            end
 
-          begin
-            results << Rdkafka::Consumer::Message.new(native_message)
-          rescue Rdkafka::RdkafkaError => e
-            # A message that fails to build (e.g. a header read error) is surfaced inline as an
-            # error event rather than discarding the whole batch - including the messages already
-            # built - and raising, which silently lost them once their offsets had been stored.
-            results << e
+            begin
+              results << Rdkafka::Consumer::Message.new(native_message)
+            rescue Rdkafka::RdkafkaError => e
+              # A message that fails to build (e.g. a header read error) is surfaced inline as an
+              # error event rather than discarding the whole batch - including the messages already
+              # built - and raising, which silently lost them once their offsets had been stored.
+              results << e
+            end
           ensure
             Rdkafka::Bindings.rd_kafka_message_destroy(ptr)
           end
-
-          i += 1
         end
       ensure
         while i < count

data/lib/rdkafka/version.rb

@@ -2,9 +2,9 @@
 
 module Rdkafka
   # Current rdkafka-ruby gem version
-  VERSION = "0.29.1"
+  VERSION = "0.30.0"
   # Target librdkafka version to be used
-  LIBRDKAFKA_VERSION = "2.14.2"
+  LIBRDKAFKA_VERSION = "2.15.0"
   # SHA256 hash of the librdkafka source tarball for verification
-  LIBRDKAFKA_SOURCE_SHA256 = "d7eec9c31c817fa44402f679c252dfbf97e4c338a849a25c3579a31fd127beb8"
+  LIBRDKAFKA_SOURCE_SHA256 = "259015220cdca708afe838b5aa79ebf1a5fb710fb4179cf918d390aed85d5dbc"
 end

data/lib/rdkafka.rb

@@ -13,6 +13,10 @@ require "rdkafka/helpers/list_offsets"
 require "rdkafka/defaults"
 require "rdkafka/abstract_handle"
 require "rdkafka/admin"
+require "rdkafka/admin/alter_consumer_group_offsets_handle"
+require "rdkafka/admin/alter_consumer_group_offsets_report"
+require "rdkafka/admin/delete_consumer_group_offsets_handle"
+require "rdkafka/admin/delete_consumer_group_offsets_report"
 require "rdkafka/admin/create_topic_handle"
 require "rdkafka/admin/create_topic_report"
 require "rdkafka/admin/delete_groups_handle"
@@ -46,6 +50,8 @@ require "rdkafka/callbacks/base_handler"
 require "rdkafka/callbacks/create_topic_handler"
 require "rdkafka/callbacks/delete_topic_handler"
 require "rdkafka/callbacks/create_partitions_handler"
+require "rdkafka/callbacks/alter_consumer_group_offsets_handler"
+require "rdkafka/callbacks/delete_consumer_group_offsets_handler"
 require "rdkafka/callbacks/delete_groups_handler"
 require "rdkafka/callbacks/delete_records_handler"
 require "rdkafka/callbacks/create_acl_handler"
@@ -60,6 +66,7 @@ require "rdkafka/consumer"
 require "rdkafka/consumer/headers"
 require "rdkafka/consumer/message"
 require "rdkafka/consumer/partition"
+require "rdkafka/consumer/allocator"
 require "rdkafka/consumer/topic_partition_list"
 require "rdkafka/error"
 require "rdkafka/metadata"
@@ -68,9 +75,12 @@ require "rdkafka/producer/partitions_count_cache"
 require "rdkafka/producer"
 require "rdkafka/producer/delivery_handle"
 require "rdkafka/producer/delivery_report"
+require "rdkafka/clients"
 
 # Main Rdkafka namespace of this gem
 module Rdkafka
 end
 
 Rdkafka::Bindings.rd_kafka_global_init
+
+at_exit { Rdkafka::Clients.close_all }

data/package-lock.json

@@ -103,9 +103,9 @@
       }
     },
     "node_modules/fastq": {
-      "version": "1.20.1",
-      "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.20.1.tgz",
-      "integrity": "sha512-GGToxJ/w1x32s/D2EKND7kTil4n8OVk/9mycTc4VDza13lOvpUZTGX3mFSCtV9ksdGBVzvsyAVLM6mHFThxXxw==",
+      "version": "1.20.2",
+      "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.20.2.tgz",
+      "integrity": "sha512-UpGiiODyCGprM8EPP6JodP6jC9Rws6TCuiDOD+nn0CJhR8guI3g/ozo4ugL0vJ+Yz1UtJuuRPqvQuybVOF1VQA==",
       "dev": true,
       "license": "ISC",
       "dependencies": {
@@ -286,9 +286,9 @@
       }
     },
     "node_modules/smol-toml": {
-      "version": "1.7.1",
-      "resolved": "https://registry.npmjs.org/smol-toml/-/smol-toml-1.7.1.tgz",
-      "integrity": "sha512-PPlsspAZ4jbMBu5DMFhfUGDQLu/vrL4SyBROVS37x8ynnVmFIs1VPBz1Co8Xks3TvpIaZXmU85y4DrQ+UyVFoQ==",
+      "version": "1.8.0",
+      "resolved": "https://registry.npmjs.org/smol-toml/-/smol-toml-1.8.0.tgz",
+      "integrity": "sha512-kCZr2V3ch9i00x8zXRhjUNVcjG9ijES5dDudkXvUVCT5QlJNQWElSJdZqyPemffHoLNUYwOcou0Fy+ojN0uHSQ==",
       "dev": true,
       "license": "BSD-3-Clause",
       "engines": {

data/renovate.json

@@ -27,7 +27,7 @@
       ],
       "depNameTemplate": "openssl/openssl",
       "datasourceTemplate": "github-releases",
-      "extractVersionTemplate": "^OpenSSL_(?<version>.*)$"
+      "extractVersionTemplate": "^openssl-(?<version>.*)$"
     },
     {
       "customType": "regex",