fast-prometheus 0.2.0 → 0.3.0

data/lib/fast/prometheus/formats/text.rb

@@ -7,6 +7,10 @@ module Fast
     module Formats
       # Prometheus text exposition format 0.0.4.
       # Consumes Snapshot value objects; never reads live metrics.
+      #
+      # Every piece is appended straight to the output buffer: no line, label
+      # or name is built as its own String first, so a render allocates one
+      # String per sample (the value's to_s) and nothing per label.
       module Text
         CONTENT_TYPE = "text/plain; version=0.0.4; charset=utf-8"
 
@@ -20,69 +24,75 @@ module Fast
           snapshot.metrics.each_with_object(String.new) do |metric, output|
             next if metric.type == :native_histogram
 
-            output << "# HELP #{metric.name} #{escape_doc(metric.docstring)}\n"
-            output << "# TYPE #{metric.name} #{metric.type}\n"
+            name = metric.name.name
+            output << "# HELP " << name << " " << escape_doc(metric.docstring) << "\n"
+            output << "# TYPE " << name << " " << metric.type.name << "\n"
 
-            metric.series.each do |series|
-              render_series(output, metric.type, metric.name, series)
+            names = metric.label_names
+            metric.series.each_pair do |values, value|
+              render_series(output, metric.type, name, names, values, value)
             end
           end
         end
 
-        private_class_method def self.render_series(output, type, name, series)
+        private_class_method def self.render_series(output, type, name, names, values, value)
           case type
           when :counter, :gauge
-            metric_line(output, name, series.labels, series.value)
+            sample(output, name, nil, names, values, value)
           when :histogram
-            histogram_lines(output, name, series.labels, series.value)
+            histogram_lines(output, name, names, values, value)
           when :summary
-            summary_lines(output, name, series.labels, series.value)
+            sample(output, name, "_sum", names, values, value.sum)
+            sample(output, name, "_count", names, values, value.count)
           end
         end
 
-        private_class_method def self.escape_doc(string)
-          return string unless DOC_ESCAPE.match?(string)
-
-          string.gsub(DOC_ESCAPE, DOC_REPLACE)
+        # One sample line: name, optional suffix, labels (names and values
+        # side by side, plus an le label carrying +upper_bound+ for histogram
+        # buckets), value.
+        private_class_method def self.sample(output, name, suffix, names, values, value, upper_bound = nil)
+          output << name
+          output << suffix if suffix
+          append_labels(output, names, values, upper_bound)
+          output << " " << value.to_s << "\n"
         end
 
-        private_class_method def self.escape_label(string)
-          string = string.to_s
-          return string unless LABEL_ESCAPE.match?(string)
+        private_class_method def self.append_labels(output, names, values, upper_bound)
+          return if names.empty? && upper_bound.nil?
 
-          string.gsub(LABEL_ESCAPE, LABEL_REPLACE)
+          output << "{"
+          names.each_index { |i| output << label_name(names[i]) << "=\"" << escape_label(values[i]) << "\"," }
+          output << "le=\"" << upper_bound << "\"," if upper_bound
+          output.chop!
+          output << "}"
         end
 
-        private_class_method def self.format_labels(labels)
-          return "" if labels.empty?
-
-          output = String.new("{")
-          labels.each do |key, value|
-            output << "#{key}=\"#{escape_label(value)}\""
-            output << ","
+        private_class_method def self.histogram_lines(output, name, names, values, value)
+          value.cumulative_buckets.each do |boundary, count|
+            sample(output, name, "_bucket", names, values, count, boundary.infinite? ? "+Inf" : boundary.to_s)
           end
-          output.chop!
-          output << "}"
-          output
+
+          sample(output, name, "_sum", names, values, value.sum)
+          sample(output, name, "_count", names, values, value.count)
         end
 
-        private_class_method def self.metric_line(output, name, labels, value)
-          output << "#{name}#{format_labels(labels)} #{value}\n"
+        # Label names are Symbols (Symbol#name is frozen and shared); a
+        # String name is appended as is.
+        private_class_method def self.label_name(key)
+          key.is_a?(Symbol) ? key.name : key
         end
 
-        private_class_method def self.histogram_lines(output, name, labels, value)
-          value.cumulative_buckets.each do |boundary, count|
-            le = boundary.infinite? ? "+Inf" : boundary.to_s
-            metric_line(output, "#{name}_bucket", labels.merge("le" => le), count)
-          end
+        private_class_method def self.escape_doc(string)
+          return string unless DOC_ESCAPE.match?(string)
 
-          metric_line(output, "#{name}_sum", labels, value.sum)
-          metric_line(output, "#{name}_count", labels, value.count)
+          string.gsub(DOC_ESCAPE, DOC_REPLACE)
         end
 
-        private_class_method def self.summary_lines(output, name, labels, value)
-          metric_line(output, "#{name}_sum", labels, value.sum)
-          metric_line(output, "#{name}_count", labels, value.count)
+        private_class_method def self.escape_label(string)
+          string = string.to_s
+          return string unless LABEL_ESCAPE.match?(string)
+
+          string.gsub(LABEL_ESCAPE, LABEL_REPLACE)
         end
       end
     end

data/lib/fast/prometheus/gauge.rb

@@ -10,18 +10,18 @@ module Fast
         :gauge
       end
 
-      def set(value, labels: {})
+      def set(value, labels: NO_LABELS)
         raise ArgumentError, "value must be a numeric" unless value.is_a?(Numeric)
 
         key = resolve(labels)
         store.synchronize { store[key] = value.to_f }
       end
 
-      def set_to_current_time(labels: {})
+      def set_to_current_time(labels: NO_LABELS)
         set(Time.now.to_f, labels: labels)
       end
 
-      def increment(by: 1, labels: {})
+      def increment(by: 1, labels: NO_LABELS)
         raise ArgumentError, "by must be a numeric" unless by.is_a?(Numeric)
         return if by.zero?
 
@@ -29,7 +29,7 @@ module Fast
         store.synchronize { store[key] = (store[key] || 0.0) + by.to_f }
       end
 
-      def decrement(by: 1, labels: {})
+      def decrement(by: 1, labels: NO_LABELS)
         raise ArgumentError, "by must be a numeric" unless by.is_a?(Numeric)
         return if by.zero?
 

data/lib/fast/prometheus/histogram.rb

@@ -25,15 +25,19 @@ module Fast
           @cells = [0] * (buckets.size + 1)
         end
 
-        # Cumulative bucket counts, ending with [Float::INFINITY, count].
+        # Cumulative bucket counts as frozen [boundary, count] pairs, ending
+        # with [Float::INFINITY, count]. Frozen on the way out so a snapshot
+        # can hold it as is.
         def cumulative_buckets
           cumulative = 0
-          result = @buckets.each_with_index.map do |boundary, i|
+          result = Array.new(@buckets.size + 1)
+          @buckets.each_index do |i|
             cumulative += @cells[i]
-            [boundary, cumulative]
+            result[i] = [@buckets[i], cumulative].freeze
           end
           cumulative += @cells.last # overflow cell
-          result << [Float::INFINITY, cumulative]
+          result[@buckets.size] = [Float::INFINITY, cumulative].freeze
+          result.freeze
         end
       end
 
@@ -56,7 +60,7 @@ module Fast
 
       # Record an observation. Finds the first boundary >= value (inclusive le)
       # using bsearch_index. Values above the last boundary go to the overflow cell.
-      def observe(value, labels: {})
+      def observe(value, labels: NO_LABELS)
         key = resolve(labels)
         index = @buckets.bsearch_index { |boundary| boundary >= value } || @buckets.size
 
@@ -71,7 +75,7 @@ module Fast
 
       # Cumulative bucket counts for a specific series, ending with
       # [Float::INFINITY, count]. Zero-valued pairs for an unobserved series.
-      def cumulative_buckets(labels: {})
+      def cumulative_buckets(labels: NO_LABELS)
         key = resolve(labels)
         store.synchronize { slot_or_zero(key).cumulative_buckets }
       end
@@ -79,7 +83,7 @@ module Fast
       # Prometheus-client-shaped Hash: each bucket boundary's to_s => cumulative
       # count, then "+Inf" => cumulative count, then "sum" => Float sum. A
       # fresh Hash per call; zero-valued for an unobserved series.
-      def get(labels: {})
+      def get(labels: NO_LABELS)
         key = resolve(labels)
         store.synchronize { hash_shape(slot_or_zero(key)) }
       end
@@ -89,13 +93,13 @@ module Fast
       end
 
       # Reader for sum of a specific series; 0.0 when unobserved.
-      def sum(labels: {})
+      def sum(labels: NO_LABELS)
         key = resolve(labels)
         store.synchronize { slot_or_zero(key).sum }
       end
 
       # Reader for count of a specific series; 0 when unobserved.
-      def count(labels: {})
+      def count(labels: NO_LABELS)
         key = resolve(labels)
         store.synchronize { slot_or_zero(key).count }
       end
@@ -129,11 +133,7 @@ module Fast
       end
 
       def snapshot_value(slot)
-        HistogramValue.new(
-          sum: slot.sum,
-          count: slot.count,
-          cumulative_buckets: slot.cumulative_buckets.map { |pair| pair.dup.freeze }.freeze
-        )
+        HistogramValue.new(slot.sum, slot.count, slot.cumulative_buckets).freeze
       end
 
       def hash_shape(slot)

data/lib/fast/prometheus/metric.rb

@@ -15,6 +15,9 @@ module Fast
       METRIC_NAME = /\A[a-zA-Z_:][a-zA-Z0-9_:]*\z/
       LABEL_NAME = /\A[a-zA-Z_][a-zA-Z0-9_]*\z/
 
+      # The default label set, shared so an unlabeled call allocates nothing.
+      NO_LABELS = {}.freeze
+
       def initialize(name, docstring:, labels: [], preset_labels: {}, store: nil)
         validate_metric_name(name)
         validate_docstring(docstring)
@@ -38,7 +41,7 @@ module Fast
       # Returns the current value for the given label set. Scalar types
       # (Counter, Gauge) return 0.0 for unobserved series. Histogram, Summary,
       # and NativeHistogram override this with their own zero-valued shapes.
-      def get(labels: {})
+      def get(labels: NO_LABELS)
         key = resolve(labels)
         store.synchronize { store[key] || 0.0 }
       end
@@ -46,7 +49,7 @@ module Fast
       # Creates the series for +labels+ at its zero value if absent. Never
       # resets a series that already exists. Raises InvalidLabelSet on an
       # unknown or incomplete label set, same as any mutator.
-      def init_label_set(labels = {})
+      def init_label_set(labels = NO_LABELS)
         seed(resolve(labels))
       end
 
@@ -68,23 +71,25 @@ module Fast
       end
 
       def values
-        snapshot_values
+        series_map { |slot| snapshot_value(slot) }
       end
 
       # Every series' value in its frozen snapshot shape (see HistogramValue,
       # SummaryValue, NativeHistogramValue; Counter/Gauge use the already-
-      # frozen Float), keyed by label hash, built under the store lock. The
-      # seam MetricSnapshot uses to build a consistent view of every series.
+      # frozen Float), keyed by the series' label values in #labels order,
+      # the store's own key. The store is copied and its slots frozen under
+      # the lock, so this is a consistent view of every series at one
+      # instant that costs one Hash. The seam MetricSnapshot uses.
       def snapshot_values
-        series_map { |slot| snapshot_value(slot) }
+        store.synchronize { store.to_h.transform_values! { |slot| snapshot_value(slot) } }
       end
 
-      # Runs +block+ exclusively with respect to every other mutation or read
+      # Runs the block exclusively with respect to every other mutation or read
       # of this metric's store (including on metrics sharing it via
       # #with_labels). Reentrant on the same thread. This is the seam
       # MetricSnapshot uses to build a consistent snapshot of every series.
-      def synchronize(&block)
-        store.synchronize(&block)
+      def synchronize
+        store.synchronize { yield } # rubocop:disable Style/ExplicitBlockArgument
       end
 
       protected
@@ -131,9 +136,21 @@ module Fast
       end
 
       # Shared shape behind #values and #snapshot_values: every series'
-      # storage transformed by +block+, keyed by label hash, under the lock.
-      def series_map(&block)
-        store.synchronize { store.to_h.transform_keys { |key| @labels.zip(key).to_h }.transform_values(&block) }
+      # storage transformed by the block, keyed by a fresh frozen label hash,
+      # under the lock. yield, not &block: a captured block is a Proc
+      # allocation on every call.
+      def series_map
+        store.synchronize do
+          store.to_h.transform_keys { |key| label_hash(key) }.transform_values { |slot| yield slot } # rubocop:disable Style/ExplicitBlockArgument
+        end
+      end
+
+      # {name => value} for a resolved key, built without the per-pair Arrays
+      # Array#zip would make (or the iterator object each_with_index would).
+      def label_hash(key)
+        hash = {}
+        @labels.each_index { |i| hash[@labels[i]] = key[i] }
+        hash.freeze
       end
 
       # Creates the series at +key+ at its zero value if absent. Never resets

data/lib/fast/prometheus/native_histogram.rb

@@ -25,14 +25,14 @@ module Fast
           @negative = {}
         end
 
-        # Sorted array of [index, count] pairs for positive side.
+        # Sorted frozen [index, count] pairs for the positive side.
         def positive_buckets
-          @positive.sort
+          @positive.sort.each(&:freeze).freeze
         end
 
-        # Sorted array of [index, count] pairs for negative side.
+        # Sorted frozen [index, count] pairs for the negative side.
         def negative_buckets
-          @negative.sort
+          @negative.sort.each(&:freeze).freeze
         end
       end
 
@@ -64,7 +64,7 @@ module Fast
       end
 
       # Record an observation. Never raises — NaN/±Inf are handled gracefully.
-      def observe(value, labels: {})
+      def observe(value, labels: NO_LABELS)
         v = value.to_f
         key = resolve(labels)
 
@@ -109,7 +109,7 @@ module Fast
 
       # A frozen NativeHistogramValue for a label set; zero-valued at this
       # metric's schema/zero_threshold for an unobserved series.
-      def get(labels: {})
+      def get(labels: NO_LABELS)
         key = resolve(labels)
         store.synchronize { snapshot_value(store[key] || zero_value) }
       end
@@ -131,15 +131,8 @@ module Fast
       end
 
       def snapshot_value(slot)
-        NativeHistogramValue.new(
-          schema: slot.schema,
-          zero_threshold: slot.zero_threshold,
-          zero_count: slot.zero_count,
-          sum: slot.sum,
-          count: slot.count,
-          positive_buckets: slot.positive_buckets.map { |pair| pair.dup.freeze }.freeze,
-          negative_buckets: slot.negative_buckets.map { |pair| pair.dup.freeze }.freeze
-        ).freeze
+        NativeHistogramValue.new(slot.schema, slot.zero_threshold, slot.zero_count, slot.sum, slot.count,
+                                 slot.positive_buckets, slot.negative_buckets).freeze
       end
 
       def index_for(value, schema)

data/lib/fast/prometheus/otlp/mapper.rb

@@ -1,17 +1,14 @@
 # frozen_string_literal: true
 
 require "fast/prometheus"
-
-$LOAD_PATH.unshift(File.expand_path("pb", __dir__)) unless $LOAD_PATH.include?(File.expand_path("pb", __dir__))
-
-require "opentelemetry/proto/collector/metrics/v1/metrics_service_pb"
+require_relative "proto"
 
 module Fast
   module Prometheus
     module OTLP
-      # Maps a Snapshot to an ExportMetricsServiceRequest.
+      # Maps a Snapshot to a Proto::ExportMetricsServiceRequest.
       class Mapper
-        CUMULATIVE = Opentelemetry::Proto::Metrics::V1::AggregationTemporality::AGGREGATION_TEMPORALITY_CUMULATIVE
+        CUMULATIVE = :AGGREGATION_TEMPORALITY_CUMULATIVE
         private_constant :CUMULATIVE
 
         def initialize(resource_attributes: {}, start_time: Time.now)
@@ -20,15 +17,15 @@ module Fast
         end
 
         def request(snapshot)
-          Opentelemetry::Proto::Collector::Metrics::V1::ExportMetricsServiceRequest.new(
+          Proto::ExportMetricsServiceRequest.new(
             resource_metrics: [
-              Opentelemetry::Proto::Metrics::V1::ResourceMetrics.new(
-                resource: Opentelemetry::Proto::Resource::V1::Resource.new(
+              Proto::ResourceMetrics.new(
+                resource: Proto::Resource.new(
                   attributes: @resource_attributes
                 ),
                 scope_metrics: [
-                  Opentelemetry::Proto::Metrics::V1::ScopeMetrics.new(
-                    scope: Opentelemetry::Proto::Common::V1::InstrumentationScope.new(
+                  Proto::ScopeMetrics.new(
+                    scope: Proto::InstrumentationScope.new(
                       name: "fast-prometheus",
                       version: Fast::Prometheus::VERSION
                     ),
@@ -45,7 +42,7 @@ module Fast
         def build_metric(metric_snapshot, taken_at)
           time_unix_nano = (taken_at.to_f * 1_000_000_000).to_i
 
-          Opentelemetry::Proto::Metrics::V1::Metric.new(
+          Proto::Metric.new(
             name: metric_snapshot.name.to_s,
             description: metric_snapshot.docstring,
             **build_data(metric_snapshot, time_unix_nano)
@@ -56,9 +53,9 @@ module Fast
           case metric_snapshot.type
           when :counter
             {
-              sum: Opentelemetry::Proto::Metrics::V1::Sum.new(
-                data_points: metric_snapshot.series.map do |series|
-                  number_data_point(series, time_unix_nano)
+              sum: Proto::Sum.new(
+                data_points: data_points(metric_snapshot) do |attributes, value|
+                  number_data_point(attributes, value, time_unix_nano)
                 end,
                 aggregation_temporality: CUMULATIVE,
                 is_monotonic: true
@@ -66,34 +63,34 @@ module Fast
             }
           when :gauge
             {
-              gauge: Opentelemetry::Proto::Metrics::V1::Gauge.new(
-                data_points: metric_snapshot.series.map do |series|
-                  number_data_point(series, time_unix_nano)
+              gauge: Proto::Gauge.new(
+                data_points: data_points(metric_snapshot) do |attributes, value|
+                  number_data_point(attributes, value, time_unix_nano)
                 end
               )
             }
           when :histogram
             {
-              histogram: Opentelemetry::Proto::Metrics::V1::Histogram.new(
-                data_points: metric_snapshot.series.map do |series|
-                  histogram_data_point(series, time_unix_nano)
+              histogram: Proto::Histogram.new(
+                data_points: data_points(metric_snapshot) do |attributes, value|
+                  histogram_data_point(attributes, value, time_unix_nano)
                 end,
                 aggregation_temporality: CUMULATIVE
               )
             }
           when :summary
             {
-              summary: Opentelemetry::Proto::Metrics::V1::Summary.new(
-                data_points: metric_snapshot.series.map do |series|
-                  summary_data_point(series, time_unix_nano)
+              summary: Proto::Summary.new(
+                data_points: data_points(metric_snapshot) do |attributes, value|
+                  summary_data_point(attributes, value, time_unix_nano)
                 end
               )
             }
           when :native_histogram
             {
-              exponential_histogram: Opentelemetry::Proto::Metrics::V1::ExponentialHistogram.new(
-                data_points: metric_snapshot.series.map do |series|
-                  exponential_histogram_data_point(series, time_unix_nano)
+              exponential_histogram: Proto::ExponentialHistogram.new(
+                data_points: data_points(metric_snapshot) do |attributes, value|
+                  exponential_histogram_data_point(attributes, value, time_unix_nano)
                 end,
                 aggregation_temporality: CUMULATIVE
               )
@@ -101,25 +98,30 @@ module Fast
           end
         end
 
-        def number_data_point(series, time_unix_nano)
-          Opentelemetry::Proto::Metrics::V1::NumberDataPoint.new(
-            attributes: build_attributes(series.labels),
+        # One data point per series: the block gets the series' OTLP
+        # attributes and its snapshot value.
+        def data_points(metric_snapshot)
+          metric_snapshot.series.map { |values, value| yield build_attributes(metric_snapshot.labels(values)), value }
+        end
+
+        def number_data_point(attributes, value, time_unix_nano)
+          Proto::NumberDataPoint.new(
+            attributes: attributes,
             start_time_unix_nano: @start_time_unix_nano,
             time_unix_nano: time_unix_nano,
-            as_double: series.value.to_f
+            as_double: value.to_f
           )
         end
 
-        def histogram_data_point(series, time_unix_nano)
-          nv = series.value
-          bounds, counts = non_cumulative_buckets(nv.cumulative_buckets)
+        def histogram_data_point(attributes, value, time_unix_nano)
+          bounds, counts = non_cumulative_buckets(value.cumulative_buckets)
 
-          Opentelemetry::Proto::Metrics::V1::HistogramDataPoint.new(
-            attributes: build_attributes(series.labels),
+          Proto::HistogramDataPoint.new(
+            attributes: attributes,
             start_time_unix_nano: @start_time_unix_nano,
             time_unix_nano: time_unix_nano,
-            count: nv.count,
-            sum: nv.sum,
+            count: value.count,
+            sum: value.sum,
             bucket_counts: counts,
             explicit_bounds: bounds
           )
@@ -142,32 +144,28 @@ module Fast
           [bounds, counts]
         end
 
-        def summary_data_point(series, time_unix_nano)
-          sv = series.value
-
-          Opentelemetry::Proto::Metrics::V1::SummaryDataPoint.new(
-            attributes: build_attributes(series.labels),
+        def summary_data_point(attributes, value, time_unix_nano)
+          Proto::SummaryDataPoint.new(
+            attributes: attributes,
             start_time_unix_nano: @start_time_unix_nano,
             time_unix_nano: time_unix_nano,
-            count: sv.count,
-            sum: sv.sum
+            count: value.count,
+            sum: value.sum
           )
         end
 
-        def exponential_histogram_data_point(series, time_unix_nano)
-          nv = series.value
-
-          Opentelemetry::Proto::Metrics::V1::ExponentialHistogramDataPoint.new(
-            attributes: build_attributes(series.labels),
+        def exponential_histogram_data_point(attributes, value, time_unix_nano)
+          Proto::ExponentialHistogramDataPoint.new(
+            attributes: attributes,
             start_time_unix_nano: @start_time_unix_nano,
             time_unix_nano: time_unix_nano,
-            count: nv.count,
-            sum: nv.sum,
-            scale: nv.schema,
-            zero_count: nv.zero_count,
-            zero_threshold: nv.zero_threshold,
-            positive: dense_buckets(nv.positive_buckets),
-            negative: dense_buckets(nv.negative_buckets)
+            count: value.count,
+            sum: value.sum,
+            scale: value.schema,
+            zero_count: value.zero_count,
+            zero_threshold: value.zero_threshold,
+            positive: dense_buckets(value.positive_buckets),
+            negative: dense_buckets(value.negative_buckets)
           )
         end
 
@@ -175,7 +173,7 @@ module Fast
         # OTLP index = prom index - 1. Offset = min OTLP index.
         # Buckets are always sorted (from NativeHistogram::Slot#positive_buckets / #negative_buckets).
         def dense_buckets(buckets)
-          return Opentelemetry::Proto::Metrics::V1::ExponentialHistogramDataPoint::Buckets.new if buckets.empty?
+          return Proto::ExponentialHistogramDataPoint::Buckets.new if buckets.empty?
 
           first_idx, = buckets.first
           last_idx, = buckets.last
@@ -185,7 +183,7 @@ module Fast
           counts = Array.new(length, 0)
           buckets.each { |prom_idx, count| counts[prom_idx - offset - 1] = count }
 
-          Opentelemetry::Proto::Metrics::V1::ExponentialHistogramDataPoint::Buckets.new(
+          Proto::ExponentialHistogramDataPoint::Buckets.new(
             offset: offset,
             bucket_counts: counts
           )
@@ -196,9 +194,9 @@ module Fast
         end
 
         def kv(key, value)
-          Opentelemetry::Proto::Common::V1::KeyValue.new(
+          Proto::KeyValue.new(
             key: key,
-            value: Opentelemetry::Proto::Common::V1::AnyValue.new(string_value: value)
+            value: Proto::AnyValue.new(string_value: value)
           )
         end
       end