fluent-plugin-prometheus 1.8.5 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5679e5c8d8872be0448075a8c1e05c395b1f9c06a0267f568a788c77dc12dc62
-  data.tar.gz: 786191b3092cf3745ab97425e4aebb4b1cb524c907433d0f4e091dbb6d14b7f9
+  metadata.gz: 366793cd93075c7e1d63cb2641d2654f5eef5304aaa1293bb9e1dabed7d93e2f
+  data.tar.gz: 4db5c9fc80dcf10b013239bfdb6e098b53bf26c34a135f944850c70d2a36b7d9
 SHA512:
-  metadata.gz: 1b7c49f483ad596641edf01226e4282db10b72dd0117867884d0df4cf6ca0cf23c48e54eab6a2a22ca3ecae845ad8edda6e75d3532853a200b7a57ac8caca423
-  data.tar.gz: 344b9a363c49067056c4366f46b6b9f3bddf955e22a0155215158b13420027479c0a5e41da1a86b2baaf71e0b01256d90d0a0c8269c322ebe3616c861ce35a98
+  metadata.gz: 47de7cabc21f0365b8629714dbd7044e95346d5fb9ce13f7c830a8aeab66bd078769792e6af2ddf52bfc41be3b052f1f1ef912dc71d34c3db0dc94b283832238
+  data.tar.gz: 00c98825475166ae5f53e6bd85081766a38aa12b5ecddf079e0f1efcbb0eb729deacf996ee975893897aa2aeca84e35a741d23c2bf7e1f602c75876e08d317ee

data/.github/dependabot.yml

@@ -0,0 +1,6 @@
+version: 2
+updates:
+  - package-ecosystem: 'github-actions'
+    directory: '/'
+    schedule:
+      interval: 'weekly'

data/.github/workflows/linux.yml

@@ -0,0 +1,30 @@
+name: linux
+on:
+  push:
+    branches: [master]
+  pull_request:
+    branches: [master]
+jobs:
+  build:
+    runs-on: ${{ matrix.os }}
+    continue-on-error: ${{ matrix.experimental }}
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby: [ '3.2', '3.1', '3.0', '2.7' ]
+        os:
+          - ubuntu-latest
+        experimental: [false]
+    name: Ruby ${{ matrix.ruby }} unit testing on ${{ matrix.os }}
+    steps:
+    - uses: actions/checkout@v3
+    - uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby }}
+    - name: unit testing
+      env:
+        CI: true
+      run: |
+        gem install bundler rake
+        bundle install --jobs 4 --retry 3
+        bundle exec rake spec

data/ChangeLog

@@ -1,3 +1,24 @@
+Release 2.1.0 - 2023/06/15
+
+	* Add `initialized` and `initlabels` parameters to `<metric>` element
+	* in_prometheus_tail_monitor: Add file open/closed/rotation metrics
+
+Release 2.0.3 - 2022/05/06
+
+	* in_prometheus_output_monitor: Fix a bug where output_status_num_errors metric is missing
+
+Release 2.0.2 - 2021/08/02
+
+	* in_prometheus_output_monitor: Follow Fluentd's core metrics mechanism
+
+Release 2.0.1 - 2021/04/08
+
+	* out_prometheus: Allow for lookup by symbol as well as string
+
+Release 2.0.0 - 2021/02/18
+
+	* Update prometheus-client dependency to 2.1.0 or later
+
 Release 1.8.5 - 2020/11/24
 
 	* in_prometheus_monitor: Support USR2 reload

data/README.md

@@ -162,10 +162,11 @@ This plugin uses internal class of Fluentd, so it's easy to break.
 
 #### Exposed metrics
 
-- `fluentd_tail_file_position`
-    - Current bytes which plugin reads from the file
-- `fluentd_tail_file_inode`
-    - inode of the file
+- `fluentd_tail_file_position`: Current bytes which plugin reads from the file
+- `fluentd_tail_file_inode`: inode of the file
+- `fluentd_tail_file_closed`: Number of closed files
+- `fluentd_tail_file_opened`: Number of opened files
+- `fluentd_tail_file_rotated`: Number of rotated files
 
 Default labels:
 
@@ -286,7 +287,9 @@ For details of each metric type, see [Prometheus documentation](http://prometheu
 - `type`: metric type (required)
 - `desc`: description of this metric (required)
 - `key`: key name of record for instrumentation (**optional**)
+- `initialized`: boolean controlling initilization of metric (**optional**). See [Metric initialization](#metric-initialization)
 - `<labels>`: additional labels for this metric (optional). See [Labels](#labels)
+- `<initlabels>`: labels to use for initialization of ReccordAccessors/Placeholder labels (**optional**). See [Metric initialization](#metric-initialization)
 
 If key is empty, the metric values is treated as 1, so the counter increments by 1 on each record regardless of contents of the record.
 
@@ -310,7 +313,9 @@ If key is empty, the metric values is treated as 1, so the counter increments by
 - `type`: metric type (required)
 - `desc`: description of metric (required)
 - `key`: key name of record for instrumentation (required)
+- `initialized`: boolean controlling initilization of metric (**optional**). See [Metric initialization](#metric-initialization)
 - `<labels>`: additional labels for this metric (optional). See [Labels](#labels)
+- `<initlabels>`: labels to use for initialization of ReccordAccessors/Placeholder labels (**optional**). See [Metric initialization](#metric-initialization)
 
 ### summary type
 
@@ -332,7 +337,9 @@ If key is empty, the metric values is treated as 1, so the counter increments by
 - `type`: metric type (required)
 - `desc`: description of metric (required)
 - `key`: key name of record for instrumentation (required)
+- `initialized`: boolean controlling initilization of metric (**optional**). See [Metric initialization](#metric-initialization)
 - `<labels>`: additional labels for this metric (optional). See [Labels](#labels)
+- `<initlabels>`: labels to use for initialization of ReccordAccessors/Placeholder labels (**optional**). See [Metric initialization](#metric-initialization)
 
 ### histogram type
 
@@ -355,8 +362,10 @@ If key is empty, the metric values is treated as 1, so the counter increments by
 - `type`: metric type (required)
 - `desc`: description of metric (required)
 - `key`: key name of record for instrumentation (required)
+- `initialized`: boolean controlling initilization of metric (**optional**). See [Metric initialization](#metric-initialization)
 - `buckets`: buckets of record for instrumentation (optional)
 - `<labels>`: additional labels for this metric (optional). See [Labels](#labels)
+- `<initlabels>`: labels to use for initialization of ReccordAccessors/Placeholder labels (**optional**). See [Metric initialization](#metric-initialization)
 
 ## Labels
 
@@ -395,6 +404,53 @@ Reserved placeholders are:
   - where `tagsize` is the size of tag which is splitted with `.` (when tag is `1.2.3`, then `tagsize` is 3)
   - only available in Prometheus output/filter plugin
 
+### Metric initialization
+
+You can configure if a metric should be initialized to its zero value before receiving any event. To do so you just need to specify `initialized true`.
+
+```
+<metric>
+  name message_bar_counter
+  type counter
+  desc The total number of bar in message.
+  key bar
+  initialized true
+  <labels>
+    foo bar
+  </labels>
+</metric>
+```
+
+If your labels contains ReccordAccessors or Placeholders, you must use `<initlabels>` to specify the values your ReccordAccessors/Placeholders will take. This feature is useful only if your Placeholders/ReccordAccessors contain deterministic values. Initialization will create as many zero value metrics as `<initlabels>` blocks you defined.
+Potential reserved placeholders `${hostname}` and `${worker_id}`, as well as static labels, are automatically added and should not be specified in `<initlabels>` configuration.
+
+```
+<metric>
+  name message_bar_counter
+  type counter
+  desc The total number of bar in message.
+  key bar
+  initialized true
+  <labels>
+    key $.foo
+    tag ${tag}
+    foo bar
+    worker_id ${worker_id}
+  </labels>
+  <initlabels>
+    key foo1
+    tag tag1
+  </initlabels>
+  <initlabels>
+    key foo2
+    tag tag2
+  </initlabels>
+</metric>
+<labels>
+  hostname ${hostname}
+</labels>
+```
+
 ### top-level labels and labels inside metric
 
 Prometheus output/filter plugin can have multiple metric section. Top-level labels section specifies labels for all metrics. Labels section inside metric section specifies labels for the metric. Both are specified, labels are merged.

data/fluent-plugin-prometheus.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |spec|
   spec.name          = "fluent-plugin-prometheus"
-  spec.version       = "1.8.5"
+  spec.version       = "2.1.0"
   spec.authors       = ["Masahiro Sano"]
   spec.email         = ["sabottenda@gmail.com"]
   spec.summary       = %q{A fluent plugin that collects metrics and exposes for Prometheus.}
@@ -14,7 +14,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency "fluentd", ">= 1.9.1", "< 2"
-  spec.add_dependency "prometheus-client", "< 0.10"
+  spec.add_dependency "prometheus-client", ">= 2.1.0"
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec"

data/lib/fluent/plugin/in_prometheus_monitor.rb

@@ -76,14 +76,14 @@ module Fluent::Plugin
 
         @monitor_info.each do |name, metric|
           if info[name]
-            metric.set(label, info[name])
+            metric.set(info[name], labels: label)
           end
         end
 
         timekeys = info["buffer_timekeys"]
         if timekeys && !timekeys.empty?
-          @buffer_newest_timekey.set(label, timekeys.max)
-          @buffer_oldest_timekey.set(label, timekeys.min)
+          @buffer_newest_timekey.set(timekeys.max, labels: label)
+          @buffer_oldest_timekey.set(timekeys.min, labels: label)
         end
       end
     end
@@ -100,7 +100,7 @@ module Fluent::Plugin
       if @registry.exist?(name)
         @registry.get(name)
       else
-        @registry.gauge(name, docstring)
+        @registry.gauge(name, docstring: docstring, labels: @base_labels.keys + [:plugin_id, :plugin_category, :type])
       end
     end
   end

data/lib/fluent/plugin/in_prometheus_output_monitor.rb

@@ -133,18 +133,26 @@ module Fluent::Plugin
 
       monitor_info = {
         # buffer metrics
-        'buffer_total_queued_size' => @metrics[:buffer_total_queued_size],
-        'buffer_stage_length' => @metrics[:buffer_stage_length],
-        'buffer_stage_byte_size' => @metrics[:buffer_stage_byte_size],
-        'buffer_queue_length' => @metrics[:buffer_queue_length],
-        'buffer_queue_byte_size' => @metrics[:buffer_queue_byte_size],
-        'buffer_available_buffer_space_ratios' => @metrics[:buffer_available_buffer_space_ratios],
-        'buffer_newest_timekey' => @metrics[:buffer_newest_timekey],
-        'buffer_oldest_timekey' => @metrics[:buffer_oldest_timekey],
+        'buffer_total_queued_size' => [@metrics[:buffer_total_queued_size]],
+        'buffer_stage_length' => [@metrics[:buffer_stage_length]],
+        'buffer_stage_byte_size' => [@metrics[:buffer_stage_byte_size]],
+        'buffer_queue_length' => [@metrics[:buffer_queue_length]],
+        'buffer_queue_byte_size' => [@metrics[:buffer_queue_byte_size]],
+        'buffer_available_buffer_space_ratios' => [@metrics[:buffer_available_buffer_space_ratios]],
+        'buffer_newest_timekey' => [@metrics[:buffer_newest_timekey]],
+        'buffer_oldest_timekey' => [@metrics[:buffer_oldest_timekey]],
 
         # output metrics
-        'retry_count' => @metrics[:retry_counts],
+        'retry_count' => [@metrics[:retry_counts], @metrics[:num_errors]],
+        # Needed since Fluentd v1.14 due to metrics extensions.
+        'write_count' => [@metrics[:write_count]],
+        'emit_count' => [@metrics[:emit_count]],
+        'emit_records' => [@metrics[:emit_records]],
+        'rollback_count' => [@metrics[:rollback_count]],
+        'flush_time_count' => [@metrics[:flush_time_count]],
+        'slow_flush_count' => [@metrics[:slow_flush_count]],
       }
+      # No needed for Fluentd v1.14 but leave as-is for backward compatibility.
       instance_vars_info = {
         num_errors: @metrics[:num_errors],
         write_count: @metrics[:write_count],
@@ -158,12 +166,14 @@ module Fluent::Plugin
       agent_info.each do |info|
         label = labels(info)
 
-        monitor_info.each do |name, metric|
-          if info[name]
-            if metric.is_a?(::Prometheus::Client::Gauge)
-              metric.set(label, info[name])
-            elsif metric.is_a?(::Prometheus::Client::Counter)
-              metric.increment(label, info[name] - metric.get(label))
+        monitor_info.each do |name, metrics|
+          metrics.each do |metric|
+            if info[name]
+              if metric.is_a?(::Prometheus::Client::Gauge)
+                metric.set(info[name], labels: label)
+              elsif metric.is_a?(::Prometheus::Client::Counter)
+                metric.increment(by: info[name] - metric.get(labels: label), labels: label)
+              end
             end
           end
         end
@@ -172,9 +182,9 @@ module Fluent::Plugin
           instance_vars_info.each do |name, metric|
             if info['instance_variables'][name]
               if metric.is_a?(::Prometheus::Client::Gauge)
-                metric.set(label, info['instance_variables'][name])
+                metric.set(info['instance_variables'][name], labels: label)
               elsif metric.is_a?(::Prometheus::Client::Counter)
-                metric.increment(label, info['instance_variables'][name] - metric.get(label))
+                metric.increment(by: info['instance_variables'][name] - metric.get(labels: label), labels: label)
               end
             end
           end
@@ -193,7 +203,7 @@ module Fluent::Plugin
           if next_time && start_time
             wait = next_time - start_time
           end
-          @metrics[:retry_wait].set(label, wait.to_f)
+          @metrics[:retry_wait].set(wait.to_f, labels: label)
         end
       end
     end
@@ -209,7 +219,7 @@ module Fluent::Plugin
       if @registry.exist?(name)
         @registry.get(name)
       else
-        @registry.gauge(name, docstring)
+        @registry.gauge(name, docstring: docstring, labels: @base_labels.keys + [:plugin_id, :type])
       end
     end
 
@@ -217,7 +227,7 @@ module Fluent::Plugin
       if @registry.exist?(name)
         @registry.get(name)
       else
-        @registry.public_send(@gauge_or_counter, name, docstring)
+        @registry.public_send(@gauge_or_counter, name, docstring: docstring, labels: @base_labels.keys + [:plugin_id, :type])
       end
     end
   end

data/lib/fluent/plugin/in_prometheus_tail_monitor.rb

@@ -51,6 +51,15 @@ module Fluent::Plugin
         inode: get_gauge(
           :fluentd_tail_file_inode,
           'Current inode of file.'),
+        closed_file_metrics: get_gauge(
+          :fluentd_tail_file_closed,
+          'Number of files closed.'),
+        opened_file_metrics: get_gauge(
+          :fluentd_tail_file_opened,
+          'Number of files opened.'),
+        rotated_file_metrics: get_gauge(
+          :fluentd_tail_file_rotated,
+          'Number of files rotated.'),
       }
       timer_execute(:in_prometheus_tail_monitor, @interval, &method(:update_monitor_info))
     end
@@ -72,9 +81,15 @@ module Fluent::Plugin
           # Access to internal variable of internal class...
           # Very fragile implementation
           pe = watcher.instance_variable_get(:@pe)
+          monitor_info = watcher.instance_variable_get(:@metrics)
           label = labels(info, watcher.path)
-          @metrics[:inode].set(label, pe.read_inode)
-          @metrics[:position].set(label, pe.read_pos)
+          @metrics[:inode].set(pe.read_inode, labels: label)
+          @metrics[:position].set(pe.read_pos, labels: label)
+          unless monitor_info.nil?
+            @metrics[:closed_file_metrics].set(monitor_info.closed.get, labels: label)
+            @metrics[:opened_file_metrics].set(monitor_info.opened.get, labels: label)
+            @metrics[:rotated_file_metrics].set(monitor_info.rotated.get, labels: label)
+          end
         end
       end
     end
@@ -91,7 +106,7 @@ module Fluent::Plugin
       if @registry.exist?(name)
         @registry.get(name)
       else
-        @registry.gauge(name, docstring)
+        @registry.gauge(name, docstring: docstring, labels: @base_labels.keys + [:plugin_id, :type, :path])
       end
     end
   end

data/lib/fluent/plugin/prometheus.rb

@@ -56,6 +56,69 @@ module Fluent
         base_labels
       end
 
+      def self.parse_initlabels_elements(conf, base_labels)
+        base_initlabels = []
+
+        # We first treat the special case of RecordAccessors and Placeholders labels if any declared
+        conf.elements.select { |e| e.name == 'initlabels' }.each { |block|
+          initlabels = {}
+
+          block.each do |key, value|
+            if not base_labels.has_key? key.to_sym
+              raise ConfigError, "Key #{key} in <initlabels> is non existent in <labels> for metric #{conf['name']}"
+            end
+
+            if value.start_with?('$.') || value.start_with?('$[') || value.start_with?('${')
+              raise ConfigError, "Cannot use RecordAccessor or placeholder #{value} (key #{key}) in a <initlabels> in metric #{conf['name']}"
+            end
+
+            base_label_value = base_labels[key.to_sym]
+
+            if !(base_label_value.class == Fluent::PluginHelper::RecordAccessor::Accessor) && ! (base_label_value.start_with?('${') )
+              raise ConfigError, "Cannot set <initlabels> on non RecordAccessor/Placeholder key #{key} (value #{value}) in metric #{conf['name']}"
+            end
+
+            if base_label_value == '${worker_id}' || base_label_value == '${hostname}'
+              raise ConfigError, "Cannot set <initlabels> on reserved placeholder #{base_label_value} for key #{key} in metric #{conf['name']}"
+            end
+            
+            initlabels[key.to_sym] = value
+          end
+
+          # Now adding all labels that are not RecordAccessor nor Placeholder labels as is
+          base_labels.each do |key, value|
+            if base_labels[key.to_sym].class != Fluent::PluginHelper::RecordAccessor::Accessor
+              if value == '${worker_id}'
+                # We retrieve fluentd_worker_id this way to not overcomplicate the code
+                initlabels[key.to_sym] = (ENV['SERVERENGINE_WORKER_ID'] || 0).to_i
+              elsif value == '${hostname}'
+                initlabels[key.to_sym] = Socket.gethostname
+              elsif !(value.start_with?('${'))
+                initlabels[key.to_sym] = value
+              end
+            end
+          end
+
+          base_initlabels << initlabels
+        }
+
+        # Testing for RecordAccessor/Placeholder labels missing a declaration in <initlabels> blocks
+        base_labels.each do |key, value|
+          if value.class == Fluent::PluginHelper::RecordAccessor::Accessor || value.start_with?('${')
+            if not base_initlabels.map(&:keys).flatten.include? (key.to_sym)
+                raise ConfigError, "RecordAccessor/Placeholder key #{key} with value #{value} has not been set in a <initlabels> for initialized metric #{conf['name']}"
+            end
+          end
+        end
+
+        if base_initlabels.length == 0
+          # There were no RecordAccessor nor Placeholder labels, we blunty retrieve the static base_labels
+          base_initlabels << base_labels
+        end
+
+        base_initlabels
+      end
+
       def self.parse_metrics_elements(conf, registry, labels = {})
         metrics = []
         conf.elements.select { |element|
@@ -85,6 +148,18 @@ module Fluent
         Fluent::Plugin::Prometheus::ExpandBuilder.new(log: log)
       end
 
+      def stringify_keys(hash_to_stringify)
+        # Adapted from: https://www.jvt.me/posts/2019/09/07/ruby-hash-keys-string-symbol/
+        hash_to_stringify.map do |k,v|
+          value_or_hash = if v.instance_of? Hash
+                            stringify_keys(v)
+                          else
+                            v
+                          end
+          [k.to_s, value_or_hash]
+        end.to_h
+      end
+
       def configure(conf)
         super
         @placeholder_values = {}
@@ -99,6 +174,7 @@ module Fluent
           'worker_id' => fluentd_worker_id,
         }
 
+        record = stringify_keys(record)
         placeholders = record.merge(@placeholder_values[tag])
         expander = @placeholder_expander_builder.build(placeholders)
         metrics.each do |metric|
@@ -119,6 +195,7 @@ module Fluent
         }
 
         es.each do |time, record|
+          record = stringify_keys(record)
           placeholders = record.merge(placeholder_values)
           expander = @placeholder_expander_builder.build(placeholders)
           metrics.each do |metric|
@@ -148,9 +225,27 @@ module Fluent
           @name = element['name']
           @key = element['key']
           @desc = element['desc']
-
+          element['initialized'].nil? ? @initialized = false : @initialized = element['initialized'] == 'true'
+          
           @base_labels = Fluent::Plugin::Prometheus.parse_labels_elements(element)
           @base_labels = labels.merge(@base_labels)
+
+          if @initialized
+            @base_initlabels = Fluent::Plugin::Prometheus.parse_initlabels_elements(element, @base_labels)
+          end
+        end
+
+        def self.init_label_set(metric, base_initlabels, base_labels)
+          base_initlabels.each { |initlabels|
+            # Should never happen, but handy test should code evolution break current implementation
+            if initlabels.keys.sort != base_labels.keys.sort
+              raise ConfigError, "initlabels for metric #{metric.name} must have the same signature than labels " \
+                                "(initlabels given: #{initlabels.keys} vs." \
+                                " expected from labels: #{base_labels.keys})"
+            end
+
+            metric.init_label_set(initlabels)
+          }
         end
 
         def labels(record, expander)
@@ -188,10 +283,14 @@ module Fluent
           end
 
           begin
-            @gauge = registry.gauge(element['name'].to_sym, element['desc'])
+            @gauge = registry.gauge(element['name'].to_sym, docstring: element['desc'], labels: @base_labels.keys)
           rescue ::Prometheus::Client::Registry::AlreadyRegisteredError
             @gauge = Fluent::Plugin::Prometheus::Metric.get(registry, element['name'].to_sym, :gauge, element['desc'])
           end
+
+          if @initialized
+            Fluent::Plugin::Prometheus::Metric.init_label_set(@gauge, @base_initlabels, @base_labels)
+          end
         end
 
         def instrument(record, expander)
@@ -201,7 +300,7 @@ module Fluent
             value = @key.call(record)
           end
           if value
-            @gauge.set(labels(record, expander), value)
+            @gauge.set(value, labels: labels(record, expander))
           end
         end
       end
@@ -210,10 +309,14 @@ module Fluent
         def initialize(element, registry, labels)
           super
           begin
-            @counter = registry.counter(element['name'].to_sym, element['desc'])
+            @counter = registry.counter(element['name'].to_sym, docstring: element['desc'], labels: @base_labels.keys)
           rescue ::Prometheus::Client::Registry::AlreadyRegisteredError
             @counter = Fluent::Plugin::Prometheus::Metric.get(registry, element['name'].to_sym, :counter, element['desc'])
           end
+
+          if @initialized
+            Fluent::Plugin::Prometheus::Metric.init_label_set(@counter, @base_initlabels, @base_labels)
+          end
         end
 
         def instrument(record, expander)
@@ -229,7 +332,7 @@ module Fluent
           # ignore if record value is nil
           return if value.nil?
 
-          @counter.increment(labels(record, expander), value)
+          @counter.increment(by: value, labels: labels(record, expander))
         end
       end
 
@@ -241,10 +344,14 @@ module Fluent
           end
 
           begin
-            @summary = registry.summary(element['name'].to_sym, element['desc'])
+            @summary = registry.summary(element['name'].to_sym, docstring: element['desc'], labels: @base_labels.keys)
           rescue ::Prometheus::Client::Registry::AlreadyRegisteredError
             @summary = Fluent::Plugin::Prometheus::Metric.get(registry, element['name'].to_sym, :summary, element['desc'])
           end
+
+          if @initialized
+            Fluent::Plugin::Prometheus::Metric.init_label_set(@summary, @base_initlabels, @base_labels)
+          end
         end
 
         def instrument(record, expander)
@@ -254,7 +361,7 @@ module Fluent
             value = @key.call(record)
           end
           if value
-            @summary.observe(labels(record, expander), value)
+            @summary.observe(value, labels: labels(record, expander))
           end
         end
       end
@@ -271,13 +378,17 @@ module Fluent
               buckets = element['buckets'].split(/,/).map(&:strip).map do |e|
                 e[/\A\d+.\d+\Z/] ? e.to_f : e.to_i
               end
-              @histogram = registry.histogram(element['name'].to_sym, element['desc'], {}, buckets)
+              @histogram = registry.histogram(element['name'].to_sym, docstring: element['desc'], labels: @base_labels.keys, buckets: buckets)
             else
-              @histogram = registry.histogram(element['name'].to_sym, element['desc'])
+              @histogram = registry.histogram(element['name'].to_sym, docstring: element['desc'], labels: @base_labels.keys)
             end
           rescue ::Prometheus::Client::Registry::AlreadyRegisteredError
             @histogram = Fluent::Plugin::Prometheus::Metric.get(registry, element['name'].to_sym, :histogram, element['desc'])
           end
+
+          if @initialized
+            Fluent::Plugin::Prometheus::Metric.init_label_set(@histogram, @base_initlabels, @base_labels)
+          end
         end
 
         def instrument(record, expander)
@@ -287,7 +398,7 @@ module Fluent
             value = @key.call(record)
           end
           if value
-            @histogram.observe(labels(record, expander), value)
+            @histogram.observe(value, labels: labels(record, expander))
           end
         end
       end

data/spec/fluent/plugin/in_prometheus_spec.rb

@@ -202,7 +202,7 @@ describe Fluent::Plugin::PrometheusInput do
   describe '#run_multi_workers' do
     context '/metrics' do
       Fluent::SystemConfig.overwrite_system_config('workers' => 4) do
-        let(:config) { CONFIG + %[
+        let(:config) { FULL_CONFIG + %[
           port #{port - 2}
         ] }
 

data/spec/fluent/plugin/out_prometheus_spec.rb

@@ -16,6 +16,10 @@ describe Fluent::Plugin::PrometheusOutput do
     it_behaves_like 'output configuration'
   end
 
+  describe '#testinitlabels' do
+    it_behaves_like 'initalized metrics'
+  end
+  
   describe '#run' do
     let(:message) { {"foo" => 100, "bar" => 100, "baz" => 100, "qux" => 10} }
 
@@ -40,4 +44,29 @@ describe Fluent::Plugin::PrometheusOutput do
 
     it_behaves_like 'instruments record'
   end
+
+  describe '#run with symbolized keys' do
+    let(:message) { {:foo => 100, :bar => 100, :baz => 100, :qux => 10} }
+
+    context 'simple config' do
+      let(:config) {
+        BASE_CONFIG + %(
+          <metric>
+            name simple
+            type counter
+            desc Something foo.
+            key foo
+          </metric>
+        )
+      }
+
+      it 'adds a new counter metric' do
+        expect(registry.metrics.map(&:name)).not_to eq([:simple])
+        driver.run(default_tag: tag) { driver.feed(event_time, message) }
+        expect(registry.metrics.map(&:name)).to eq([:simple])
+      end
+    end
+
+    it_behaves_like 'instruments record'
+  end
 end

data/spec/fluent/plugin/shared.rb

@@ -27,6 +27,7 @@ FULL_CONFIG = BASE_CONFIG + %[
     type gauge
     desc Something bar.
     key bar
+    initialized true
     <labels>
       key foo2
     </labels>
@@ -36,6 +37,7 @@ FULL_CONFIG = BASE_CONFIG + %[
     type summary
     desc Something baz.
     key baz
+    initialized true
     <labels>
       key foo3
     </labels>
@@ -46,6 +48,7 @@ FULL_CONFIG = BASE_CONFIG + %[
     desc Something qux.
     key qux
     buckets 0.1, 1, 5, 10
+    initialized true
     <labels>
       key foo4
     </labels>
@@ -62,12 +65,32 @@ FULL_CONFIG = BASE_CONFIG + %[
   <metric>
     name full_accessor2
     type counter
-    desc Something with accessor.
+    desc Something with accessor
     key $.foo
+    initialized true
     <labels>
       key foo6
     </labels>
   </metric>
+  <metric>
+    name full_accessor3
+    type counter
+    desc Something with accessor and several initialized metrics
+    initialized true
+    <labels>
+      key $.foo
+      key2 $.foo2
+      key3 footix
+    </labels>
+    <initlabels>
+      key foo6
+      key2 foo7
+    </initlabels>
+    <initlabels>
+      key foo8
+      key2 foo9
+    </initlabels>
+  </metric>
   <labels>
     test_key test_value
   </labels>
@@ -79,13 +102,20 @@ PLACEHOLDER_CONFIG = BASE_CONFIG + %[
     type counter
     desc Something foo.
     key foo
+    initialized true
     <labels>
       foo ${foo}
+      foo2 foo2
     </labels>
+    <initlabels>
+      tag tag
+      foo foo
+    </initlabels>
   </metric>
   <labels>
     tag ${tag}
     hostname ${hostname}
+    workerid ${worker_id}
   </labels>
 ]
 
@@ -150,6 +180,111 @@ shared_examples_for 'output configuration' do
     end
     it { expect { driver }.to raise_error(Fluent::ConfigError) }
   end
+
+
+  context 'with missing <initlabels>' do
+    let(:config) do
+      BASE_CONFIG + %[
+      <metric>
+        name simple_foo
+        type counter
+        desc Something foo but incorrect
+        key foo
+        initialized true
+        <labels>
+          key $.accessor
+        </labels>
+      </metric>
+      ]
+    end
+    it { expect { driver }.to raise_error(Fluent::ConfigError) }
+  end
+
+  context 'with RecordAccessor set in <initlabels>' do
+    let(:config) do
+      BASE_CONFIG + %[
+      <metric>
+        name simple_foo
+        type counter
+        desc Something foo but incorrect
+        key foo
+        initialized true
+        <labels>
+          key $.accessor
+        </labels>
+        <initlabels>
+          key $.accessor2
+        <initlabels>
+      </metric>
+      ]
+    end
+    it { expect { driver }.to raise_error(Fluent::ConfigError) }
+  end
+
+  context 'with PlaceHolder set in <initlabels>' do
+    let(:config) do
+      BASE_CONFIG + %[
+      <metric>
+        name simple_foo
+        type counter
+        desc Something foo but incorrect
+        key foo
+        initialized true
+        <labels>
+          key ${foo}
+        </labels>
+        <initlabels>
+          key ${foo}
+        <initlabels>
+      </metric>
+      ]
+    end
+    it { expect { driver }.to raise_error(Fluent::ConfigError) }
+  end
+
+  context 'with non RecordAccessor label set in <initlabels>' do
+    let(:config) do
+      BASE_CONFIG + %[
+      <metric>
+        name simple_foo
+        type counter
+        desc Something foo but incorrect
+        key foo
+        initialized true
+        <labels>
+          key $.accessor
+          key2 foo2
+        </labels>
+        <initlabels>
+          key foo
+          key2 foo2
+        <initlabels>
+      </metric>
+      ]
+    end
+    it { expect { driver }.to raise_error(Fluent::ConfigError) }
+  end
+
+  context 'with non-matching label keys set in <initlabels>' do
+    let(:config) do
+      BASE_CONFIG + %[
+      <metric>
+        name simple_foo
+        type counter
+        desc Something foo but incorrect
+        key foo
+        initialized true
+        <labels>
+          key $.accessor
+        </labels>
+        <initlabels>
+          key2 foo
+        <initlabels>
+      </metric>
+      ]
+    end
+    it { expect { driver }.to raise_error(Fluent::ConfigError) }
+  end
 end
 
 shared_examples_for 'instruments record' do
@@ -165,33 +300,35 @@ shared_examples_for 'instruments record' do
     let(:histogram) { registry.get(:full_qux) }
     let(:summary_with_accessor) { registry.get(:full_accessor1) }
     let(:counter_with_accessor) { registry.get(:full_accessor2) }
+    let(:counter_with_two_accessors) { registry.get(:full_accessor3) }
 
     it 'adds all metrics' do
-      expect(registry.metrics.map(&:name)).to eq(%i[full_foo full_bar full_baz full_qux full_accessor1 full_accessor2])
+      expect(registry.metrics.map(&:name)).to eq(%i[full_foo full_bar full_baz full_qux full_accessor1 full_accessor2 full_accessor3])
       expect(counter).to be_kind_of(::Prometheus::Client::Metric)
       expect(gauge).to be_kind_of(::Prometheus::Client::Metric)
       expect(summary).to be_kind_of(::Prometheus::Client::Metric)
       expect(summary_with_accessor).to be_kind_of(::Prometheus::Client::Metric)
       expect(counter_with_accessor).to be_kind_of(::Prometheus::Client::Metric)
+      expect(counter_with_two_accessors).to be_kind_of(::Prometheus::Client::Metric)
       expect(histogram).to be_kind_of(::Prometheus::Client::Metric)
     end
 
     it 'instruments counter metric' do
       expect(counter.type).to eq(:counter)
-      expect(counter.get({test_key: 'test_value', key: 'foo1'})).to be_kind_of(Numeric)
-      expect(counter_with_accessor.get({test_key: 'test_value', key: 'foo6'})).to be_kind_of(Numeric)
+      expect(counter.get(labels: {test_key: 'test_value', key: 'foo1'})).to be_kind_of(Numeric)
+      expect(counter_with_accessor.get(labels: {test_key: 'test_value', key: 'foo6'})).to be_kind_of(Numeric)
+      expect(counter_with_two_accessors.get(labels: {test_key: 'test_value', key: 'foo6', key2: 'foo7', key3: 'footix'})).to be_kind_of(Numeric)
     end
 
     it 'instruments gauge metric' do
       expect(gauge.type).to eq(:gauge)
-      expect(gauge.get({test_key: 'test_value', key: 'foo2'})).to eq(100)
+      expect(gauge.get(labels: {test_key: 'test_value', key: 'foo2'})).to eq(100)
     end
 
     it 'instruments summary metric' do
       expect(summary.type).to eq(:summary)
-      expect(summary.get({test_key: 'test_value', key: 'foo3'})).to be_kind_of(Hash)
-      expect(summary.get({test_key: 'test_value', key: 'foo3'})[0.99]).to eq(100)
-      expect(summary_with_accessor.get({test_key: 'test_value', key: 'foo5'})[0.99]).to eq(100)
+      expect(summary.get(labels: {test_key: 'test_value', key: 'foo3'})).to be_kind_of(Hash)
+      expect(summary_with_accessor.get(labels: {test_key: 'test_value', key: 'foo5'})["sum"]).to eq(100)
     end
 
     it 'instruments histogram metric' do
@@ -200,8 +337,8 @@ shared_examples_for 'instruments record' do
       end
 
       expect(histogram.type).to eq(:histogram)
-      expect(histogram.get({test_key: 'test_value', key: 'foo4'})).to be_kind_of(Hash)
-      expect(histogram.get({test_key: 'test_value', key: 'foo4'})[10]).to eq(5) # 4 + `es` in before
+      expect(histogram.get(labels: {test_key: 'test_value', key: 'foo4'})).to be_kind_of(Hash)
+      expect(histogram.get(labels: {test_key: 'test_value', key: 'foo4'})["10"]).to eq(5) # 4 + `es` in before
     end
   end
 
@@ -231,7 +368,7 @@ shared_examples_for 'instruments record' do
       expect(counter).to be_kind_of(::Prometheus::Client::Metric)
       key, _ = counter.values.find {|k,v| v ==  100 }
       expect(key).to be_kind_of(Hash)
-      expect(key[:foo]).to eq(100)
+      expect(key[:foo]).to eq("100")
     end
   end
 
@@ -247,3 +384,66 @@ shared_examples_for 'instruments record' do
     end
   end
 end
+
+shared_examples_for 'initalized metrics' do
+  before do
+    driver.run(default_tag: tag)
+  end
+
+  context 'full config' do
+    let(:config) { FULL_CONFIG }
+    let(:counter) { registry.get(:full_foo) }
+    let(:gauge) { registry.get(:full_bar) }
+    let(:summary) { registry.get(:full_baz) }
+    let(:histogram) { registry.get(:full_qux) }
+    let(:summary_with_accessor) { registry.get(:full_accessor1) }
+    let(:counter_with_accessor) { registry.get(:full_accessor2) }
+    let(:counter_with_two_accessors) { registry.get(:full_accessor3) }
+  
+    it 'adds all metrics' do
+      expect(registry.metrics.map(&:name)).to eq(%i[full_foo full_bar full_baz full_qux full_accessor1 full_accessor2 full_accessor3])
+      expect(counter).to be_kind_of(::Prometheus::Client::Metric)
+      expect(gauge).to be_kind_of(::Prometheus::Client::Metric)
+      expect(summary).to be_kind_of(::Prometheus::Client::Metric)
+      expect(summary_with_accessor).to be_kind_of(::Prometheus::Client::Metric)
+      expect(counter_with_accessor).to be_kind_of(::Prometheus::Client::Metric)
+      expect(counter_with_two_accessors).to be_kind_of(::Prometheus::Client::Metric)
+      expect(histogram).to be_kind_of(::Prometheus::Client::Metric)
+    end
+
+    it 'tests uninitialized metrics' do
+      expect(counter.values).to eq({})
+      expect(summary_with_accessor.values).to eq({})
+    end
+
+    it 'tests initialized metrics' do
+      expect(gauge.values).to eq({{:key=>"foo2", :test_key=>"test_value"}=>0.0})
+      expect(summary.values).to eq({:key=>"foo3", :test_key=>"test_value"}=>{"count"=>0.0, "sum"=>0.0})
+      expect(histogram.values).to eq({:key=>"foo4", :test_key=>"test_value"} => {"+Inf"=>0.0, "0.1"=>0.0, "1"=>0.0, "10"=>0.0, "5"=>0.0, "sum"=>0.0})
+      expect(counter_with_accessor.values).to eq({{:key=>"foo6", :test_key=>"test_value"}=>0.0})
+      expect(counter_with_two_accessors.values).to eq({{:key=>"foo6", :key2=>"foo7", :key3=>"footix", :test_key=>"test_value"}=>0.0, {:key=>"foo8", :key2=>"foo9", :key3=>"footix", :test_key=>"test_value"}=>0.0})
+    end
+  end
+
+  context 'placeholder config' do
+    let(:config) { PLACEHOLDER_CONFIG }
+    let(:counter) { registry.get(:placeholder_foo) }
+
+    it 'expands placeholders with record values' do
+      expect(registry.metrics.map(&:name)).to eq([:placeholder_foo])
+      expect(counter).to be_kind_of(::Prometheus::Client::Metric)
+
+      key, _ = counter.values.find {|k,v| v ==  0.0 }
+      expect(key).to be_kind_of(Hash)
+      expect(key[:foo]).to eq("foo")
+      expect(key[:foo2]).to eq("foo2")
+      expect(key[:hostname]).to be_kind_of(String)
+      expect(key[:hostname]).not_to eq("${hostname}")
+      expect(key[:hostname]).not_to be_empty
+      expect(key[:workerid]).to be_kind_of(String)
+      expect(key[:workerid]).not_to eq("${worker_id}")
+      expect(key[:workerid]).not_to be_empty
+      expect(key[:tag]).to eq("tag")
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fluent-plugin-prometheus
 version: !ruby/object:Gem::Version
-  version: 1.8.5
+  version: 2.1.0
 platform: ruby
 authors:
 - Masahiro Sano
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-11-24 00:00:00.000000000 Z
+date: 2023-06-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fluentd
@@ -34,16 +34,16 @@ dependencies:
   name: prometheus-client
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "<"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.10'
+        version: 2.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "<"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.10'
+        version: 2.1.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -107,9 +107,10 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/dependabot.yml"
+- ".github/workflows/linux.yml"
 - ".gitignore"
 - ".rspec"
-- ".travis.yml"
 - ChangeLog
 - Gemfile
 - LICENSE
@@ -158,7 +159,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.3.7
 signing_key: 
 specification_version: 4
 summary: A fluent plugin that collects metrics and exposes for Prometheus.

data/.travis.yml

@@ -1,14 +0,0 @@
-language: ruby
-
-rvm:
-  - "2.4.7"
-  - "2.5"
-  - "2.6"
-
-gemfile:
-  - Gemfile
-
-script:
-  - bundle exec rake spec
-
-sudo: false