prometheus-client-mmap 0.16.2 → 0.18.0

data/ext/fast_mmaped_file/value_access.c

@@ -66,7 +66,7 @@ static int perform_mmap(mm_ipc *i_mm, size_t len) {
     return SUCCESS;
 }
 
-static int expand(mm_ipc *i_mm, size_t len) {
+static int expand(VALUE self, mm_ipc *i_mm, size_t len) {
     if (len < i_mm->t->len) {
         return with_exception(rb_eArgError, "Can't reduce the size of mmap");
     }
@@ -88,6 +88,8 @@ static int expand(mm_ipc *i_mm, size_t len) {
         return with_exception_errno(rb_eArgError, "mlock(%d)", errno);
     }
 
+    mm_update(self);
+
     return SUCCESS;
 }
 
@@ -151,7 +153,7 @@ uint32_t load_used(mm_ipc *i_mm) {
 
 void save_used(mm_ipc *i_mm, uint32_t used) { *((uint32_t *)i_mm->t->addr) = used; }
 
-static VALUE initialize_entry(mm_ipc *i_mm, VALUE positions, VALUE key, VALUE value) {
+static VALUE initialize_entry(VALUE self, mm_ipc *i_mm, VALUE positions, VALUE key, VALUE value) {
     if (i_mm->t->flag & MM_FROZEN) {
         rb_error_frozen("mmap");
     }
@@ -166,10 +168,11 @@ static VALUE initialize_entry(mm_ipc *i_mm, VALUE positions, VALUE key, VALUE va
 
     uint32_t used = load_used(i_mm);
     while (i_mm->t->len < (used + entry_length)) {
-        if (!expand(i_mm, i_mm->t->len * 2)) {
+        if (!expand(self, i_mm, i_mm->t->len * 2)) {
             raise_last_exception();
         }
     }
+
     save_entry(i_mm, used, key, value);
     save_used(i_mm, used + entry_length);
 
@@ -189,7 +192,7 @@ VALUE method_fetch_entry(VALUE self, VALUE positions, VALUE key, VALUE default_v
         return load_value(i_mm, position);
     }
 
-    position = initialize_entry(i_mm, positions, key, default_value);
+    position = initialize_entry(self, i_mm, positions, key, default_value);
     return load_value(i_mm, position);
 }
 
@@ -207,7 +210,7 @@ VALUE method_upsert_entry(VALUE self, VALUE positions, VALUE key, VALUE value) {
         return load_value(i_mm, position);
     }
 
-    position = initialize_entry(i_mm, positions, key, value);
+    position = initialize_entry(self, i_mm, positions, key, value);
     return load_value(i_mm, position);
 }
 
@@ -229,7 +232,7 @@ VALUE method_save_used(VALUE self, VALUE value) {
     }
 
     if (i_mm->t->len < INITIAL_SIZE) {
-        if (!expand(i_mm, INITIAL_SIZE)) {
+        if (!expand(self, i_mm, INITIAL_SIZE)) {
             raise_last_exception();
         }
     }

data/lib/mmap.rb

@@ -0,0 +1,7 @@
+require 'weak_ref'
+
+class FastMmapedFile
+  def track_ref!
+
+  end
+end

data/lib/prometheus/#client.rb#

@@ -0,0 +1,58 @@
+require 'prometheus/client/registry'
+require 'prometheus/client/configuration'
+require 'prometheus/client/mmaped_value'
+
+module Prometheus
+  # Client is a ruby implementation for a Prometheus compatible client.
+  module Client
+    class << self
+      attr_writer :configuration
+
+      def configuration
+        @configuration ||= Configuration.new
+      end
+
+      def configure
+        yield(configuration)
+      end
+o
+      # Returns a default registry object
+      def registry
+        @registry ||= Registry.new
+      end
+
+      def logger
+        configuration.logger
+      end
+
+      def pid
+        configuration.pid_provider.call
+      end
+
+      # Resets the registry and reinitializes all metrics files.
+      # Use case: clean up everything in specs `before` block,
+      # to prevent leaking the state between specs which are updating metrics.
+      def reset!
+        @registry = nil
+        ::Prometheus::Client::MmapedValue.reset_and_reinitialize
+      end
+
+      def cleanup!
+        Dir.glob("#{configuration.multiprocess_files_dir}/*.db").each { |f| File.unlink(f) if File.exist?(f) }
+      end
+
+      # With `force: false`: reinitializes metric files only for processes with the changed PID.
+      # With `force: true`: reinitializes all metrics files.
+      # Always keeps the registry.
+      # Use case  (`force: false`): pick up new metric files on each worker start,
+      # without resetting already registered files for the master or previously initialized workers.
+      def reinitialize_on_pid_change(force: false)
+        if force
+          ::Prometheus::Client::MmapedValue.reset_and_reinitialize
+        else
+          ::Prometheus::Client::MmapedValue.reinitialize_on_pid_change
+        end
+      end
+    end
+  end
+end

data/lib/prometheus/client/push.rb

@@ -1,12 +1,15 @@
 # encoding: UTF-8
 
+require 'base64'
 require 'thread'
 require 'net/http'
 require 'uri'
 require 'erb'
+require 'set'
 
 require 'prometheus/client'
 require 'prometheus/client/formats/text'
+require 'prometheus/client/label_set_validator'
 
 module Prometheus
   # Client is a ruby implementation for a Prometheus compatible client.
@@ -14,23 +17,31 @@ module Prometheus
     # Push implements a simple way to transmit a given registry to a given
     # Pushgateway.
     class Push
+      class HttpError < StandardError; end
+      class HttpRedirectError < HttpError; end
+      class HttpClientError < HttpError; end
+      class HttpServerError < HttpError; end
+
       DEFAULT_GATEWAY = 'http://localhost:9091'.freeze
       PATH            = '/metrics/job/%s'.freeze
-      INSTANCE_PATH   = '/metrics/job/%s/instance/%s'.freeze
       SUPPORTED_SCHEMES = %w(http https).freeze
 
-      attr_reader :job, :instance, :gateway, :path
+      attr_reader :job, :gateway, :path
 
-      def initialize(job:, instance: nil, gateway: DEFAULT_GATEWAY, **kwargs)
+      def initialize(job:, gateway: DEFAULT_GATEWAY, grouping_key: {}, **kwargs)
         raise ArgumentError, "job cannot be nil" if job.nil?
         raise ArgumentError, "job cannot be empty" if job.empty?
+        @validator = LabelSetValidator.new()
+        @validator.validate(grouping_key)
 
         @mutex = Mutex.new
         @job = job
-        @instance = instance
         @gateway = gateway || DEFAULT_GATEWAY
-        @path = build_path(job, instance)
+        @grouping_key = grouping_key
+        @path = build_path(job, grouping_key)
+
         @uri = parse("#{@gateway}#{@path}")
+        validate_no_basic_auth!(@uri)
 
         @http = Net::HTTP.new(@uri.host, @uri.port)
         @http.use_ssl = (@uri.scheme == 'https')
@@ -38,6 +49,11 @@ module Prometheus
         @http.read_timeout = kwargs[:read_timeout] if kwargs[:read_timeout]
       end
 
+      def basic_auth(user, password)
+        @user = user
+        @password = password
+      end
+
       def add(registry)
         synchronize do
           request(Net::HTTP::Post, registry)
@@ -70,26 +86,118 @@ module Prometheus
         raise ArgumentError, "#{url} is not a valid URL: #{e}"
       end
 
-      def build_path(job, instance)
-        if instance && !instance.empty?
-          format(INSTANCE_PATH, ERB::Util::url_encode(job), ERB::Util::url_encode(instance))
-        else
-          format(PATH, ERB::Util::url_encode(job))
+      def build_path(job, grouping_key)
+        path = format(PATH, ERB::Util::url_encode(job))
+
+        grouping_key.each do |label, value|
+          if value.include?('/')
+            encoded_value = Base64.urlsafe_encode64(value)
+            path += "/#{label}@base64/#{encoded_value}"
+          # While it's valid for the urlsafe_encode64 function to return an
+          # empty string when the input string is empty, it doesn't work for
+          # our specific use case as we're putting the result into a URL path
+          # segment. A double slash (`//`) can be normalised away by HTTP
+          # libraries, proxies, and web servers.
+          #
+          # For empty strings, we use a single padding character (`=`) as the
+          # value.
+          #
+          # See the pushgateway docs for more details:
+          #
+          # https://github.com/prometheus/pushgateway/blob/6393a901f56d4dda62cd0f6ab1f1f07c495b6354/README.md#url
+          elsif value.empty?
+            path += "/#{label}@base64/="
+          else
+            path += "/#{label}/#{ERB::Util::url_encode(value)}"
+          end
         end
+
+        path
       end
 
       def request(req_class, registry = nil)
+        validate_no_label_clashes!(registry) if registry
+
         req = req_class.new(@uri)
         req.content_type = Formats::Text::CONTENT_TYPE
-        req.basic_auth(@uri.user, @uri.password) if @uri.user
+        req.basic_auth(@user, @password) if @user
         req.body = Formats::Text.marshal(registry) if registry
 
-        @http.request(req)
+        response = @http.request(req)
+        validate_response!(response)
+
+        response
       end
 
       def synchronize
         @mutex.synchronize { yield }
       end
+
+      def validate_no_basic_auth!(uri)
+        if uri.user || uri.password
+          raise ArgumentError, <<~EOF
+            Setting Basic Auth credentials in the gateway URL is not supported, please call the `basic_auth` method.
+
+            Received username `#{uri.user}` in gateway URL. Instead of passing
+            Basic Auth credentials like this:
+
+            ```
+            push = Prometheus::Client::Push.new(job: "my-job", gateway: "http://user:password@localhost:9091")
+            ```
+
+            please pass them like this:
+
+            ```
+            push = Prometheus::Client::Push.new(job: "my-job", gateway: "http://localhost:9091")
+            push.basic_auth("user", "password")
+            ```
+
+            While URLs do support passing Basic Auth credentials using the
+            `http://user:password@example.com/` syntax, the username and
+            password in that syntax have to follow the usual rules for URL
+            encoding of characters per RFC 3986
+            (https://datatracker.ietf.org/doc/html/rfc3986#section-2.1).
+
+            Rather than place the burden of correctly performing that encoding
+            on users of this gem, we decided to have a separate method for
+            supplying Basic Auth credentials, with no requirement to URL encode
+            the characters in them.
+          EOF
+        end
+      end
+
+      def validate_no_label_clashes!(registry)
+        # There's nothing to check if we don't have a grouping key
+        return if @grouping_key.empty?
+
+        # We could be doing a lot of comparisons, so let's do them against a
+        # set rather than an array
+        grouping_key_labels = @grouping_key.keys.to_set
+
+        registry.metrics.each do |metric|
+            metric.values.keys.first.keys.each do |label|
+            if grouping_key_labels.include?(label)
+              raise LabelSetValidator::InvalidLabelSetError,
+                "label :#{label} from grouping key collides with label of the " \
+                "same name from metric :#{metric.name} and would overwrite it"
+            end
+          end
+        end
+      end
+
+      def validate_response!(response)
+        status = Integer(response.code)
+        if status >= 300
+          message = "status: #{response.code}, message: #{response.message}, body: #{response.body}"
+          if status <= 399
+            raise HttpRedirectError, message
+          elsif status <= 499
+            raise HttpClientError, message
+          else
+            raise HttpServerError, message
+          end
+        end
+      end
     end
   end
 end

data/lib/prometheus/client/version.rb

@@ -1,5 +1,5 @@
 module Prometheus
   module Client
-    VERSION = '0.16.2'.freeze
+    VERSION = '0.18.0'.freeze
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: prometheus-client-mmap
 version: !ruby/object:Gem::Version
-  version: 0.16.2
+  version: 0.18.0
 platform: ruby
 authors:
 - Tobias Schmidt
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-07-08 00:00:00.000000000 Z
+date: 2023-01-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fuzzbert
@@ -117,7 +117,9 @@ files:
 - ext/fast_mmaped_file/value_access.c
 - ext/fast_mmaped_file/value_access.h
 - lib/fast_mmaped_file.bundle
+- lib/mmap.rb
 - lib/prometheus.rb
+- lib/prometheus/#client.rb#
 - lib/prometheus/client.rb
 - lib/prometheus/client/configuration.rb
 - lib/prometheus/client/counter.rb
@@ -174,14 +176,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.16
+rubygems_version: 3.3.26
 signing_key: 
 specification_version: 4
 summary: A suite of instrumentation metric primitivesthat can be exposed through a