phihos-fluent-plugin-prometheus 2.0.3.pre.1

data/misc/prometheus.yaml

@@ -0,0 +1,13 @@
+# A job to scrape an endpoint of Fluentd running on localhost.
+scrape_configs:
+- job_name: 'prometheus'
+  scrape_interval: 5s
+  static_configs:
+    - targets:
+      - 'localhost:9090'
+- job_name: fluentd
+  scrape_interval: 5s
+  static_configs:
+    - targets:
+      - 'localhost:24231'
+  metrics_path: /metrics

data/misc/prometheus_alerts.yaml

@@ -0,0 +1,59 @@
+ALERT FluentdNodeDown
+  IF up{job="fluentd"} == 0
+  FOR 10m
+  LABELS {
+    service = "fluentd",
+    severity = "warning"
+  }
+  ANNOTATIONS {
+    summary = "fluentd cannot be scraped",
+    description = "Prometheus could not scrape {{ $labels.job }} for more than 10 minutes",
+  }
+  
+ALERT FluentdNodeDown
+  IF up{job="fluentd"} == 0
+  FOR 30m
+  LABELS {
+    service = "fluentd",
+    severity = "critical"
+  }
+  ANNOTATIONS {
+    summary = "fluentd cannot be scraped",
+    description = "Prometheus could not scrape {{ $labels.job }} for more than 30 minutes",
+  }
+  
+ALERT FluentdQueueLength
+  IF rate(fluentd_status_buffer_queue_length[5m]) > 0.3
+  FOR 1m
+  LABELS {
+    service = "fluentd",
+    severity = "warning"
+  }
+  ANNOTATIONS {
+    summary = "fluentd node are failing",
+    description = "In the last 5 minutes, fluentd queues increased 30%. Current value is {{ $value }} ",
+  }
+
+ALERT FluentdQueueLength
+  IF rate(fluentd_status_buffer_queue_length[5m]) > 0.5
+  FOR 1m
+  LABELS {
+    service = "fluentd",
+    severity = "critical"
+  }
+  ANNOTATIONS {
+    summary = "fluentd node are critical",
+    description = "In the last 5 minutes, fluentd queues increased 50%. Current value is {{ $value }} ",
+  }
+
+ALERT FluentdRecordsCountsHigh
+  IF sum(rate(fluentd_output_status_emit_records{job="fluentd"}[5m])) BY (instance) >  (3 * sum(rate(fluentd_output_status_emit_records{job="fluentd"}[15m])) BY (instance))
+  FOR 1m
+  LABELS {
+    service = "fluentd",
+    severity = "critical"
+  }
+  ANNOTATIONS {
+    summary = "fluentd records count are critical",
+    description = "In the last 5m, records counts increased 3 times, comparing to the latest 15 min.",
+  }

data/spec/fluent/plugin/filter_prometheus_spec.rb

@@ -0,0 +1,145 @@
+require 'spec_helper'
+require 'fluent/test/driver/filter'
+require 'fluent/plugin/filter_prometheus'
+require_relative 'shared'
+
+describe Fluent::Plugin::PrometheusFilter do
+  let(:tag) { 'prometheus.test' }
+  let(:driver) { Fluent::Test::Driver::Filter.new(Fluent::Plugin::PrometheusFilter).configure(config) }
+  let(:registry) { ::Prometheus::Client::Registry.new }
+
+  before do
+    allow(Prometheus::Client).to receive(:registry).and_return(registry)
+  end
+
+  describe '#configure' do
+    it_behaves_like 'output configuration'
+  end
+
+  describe '#run' 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
+
+      it 'should keep original message' do
+        driver.run(default_tag: tag) { driver.feed(event_time, message) }
+        expect(driver.filtered_records.first).to eq(message)
+      end
+    end
+
+    it_behaves_like 'instruments record'
+  end
+
+  describe '#run with retention' do
+    let(:message) { { "foo" => 100, "bar" => 100, "baz" => 100, "qux" => 10 } }
+
+    context 'config with retention 1' do
+      let(:config) {
+        BASE_CONFIG + %(
+          <metric>
+            name simple
+            type counter
+            desc Something foo.
+            key foo
+            <labels>
+              bar ${bar}
+              baz ${baz}
+              qux ${qux}
+            </labels>
+            retention 1
+            retention_check_interval 1
+          </metric>
+        )
+      }
+
+      it 'expires metric after max 2s' do
+        expect(registry.metrics.map(&:name)).not_to eq([:simple])
+        driver.run(default_tag: tag) {
+          driver.feed(event_time, message)
+          expect(registry.metrics[0].get(labels: { :bar => 100, :baz => 100, :qux => 10 })).to eq(100)
+          sleep(2)
+          expect(registry.metrics[0].get(labels: { :bar => 100, :baz => 100, :qux => 10 })).to eq(0.0)
+        }
+      end
+    end
+  end
+
+  describe '#run with topk' do
+    let(:message1) { { "foo" => 200, "bar" => "a" } }
+    let(:message2) { { "foo" => 300, "bar" => "b" } }
+    let(:message3) { { "foo" => 100, "bar" => "c" } }
+
+    context 'config with topk 2' do
+      let(:config) {
+        BASE_CONFIG + %(
+          <metric>
+            name simple
+            type counter
+            desc Something foo.
+            key foo
+            <labels>
+              bar ${bar}
+            </labels>
+            topk 2
+          </metric>
+        )
+      }
+
+      it 'shows only top 2 metrics' do
+        expect(registry.metrics.map(&:name)).not_to eq([:simple])
+        driver.run(default_tag: tag) {
+          driver.feed(event_time, message1)
+          driver.feed(event_time, message2)
+          driver.feed(event_time, message3)
+        }
+        expect(registry.metrics[0].values).to eq({
+                                                   { :bar => "a" } => 200,
+                                                   { :bar => "b" } => 300,
+                                                 })
+      end
+    end
+  end
+
+  describe '#run with reset_after' do
+    let(:message) { { "foo" => 100 } }
+
+    context 'config with reset_after 1' do
+      let(:config) {
+        BASE_CONFIG + %(
+          <metric>
+            name simple
+            type counter
+            desc Something foo.
+            key foo
+            reset_after 1
+          </metric>
+        )
+      }
+
+      it 'resets metric values after max 2s' do
+        expect(registry.metrics.map(&:name)).not_to eq([:simple])
+        driver.run(default_tag: tag) {
+          driver.feed(event_time, message)
+          sleep(2)
+        }
+        expect(registry.metrics[0].values).to eq({ {} => 0 })
+      end
+    end
+  end
+end

data/spec/fluent/plugin/in_prometheus_monitor_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+require 'fluent/plugin/in_prometheus_monitor'
+require 'fluent/test/driver/input'
+
+describe Fluent::Plugin::PrometheusMonitorInput do
+  MONITOR_CONFIG = %[
+  @type prometheus_monitor
+  <labels>
+    host ${hostname}
+    foo bar
+  </labels>
+]
+
+  INVALID_MONITOR_CONFIG = %[
+  @type prometheus_monitor
+
+  <labels>
+    host ${hostname}
+    foo bar
+    invalid_use1 $.foo.bar
+    invalid_use2 $[0][1]
+  </labels>
+]
+
+  let(:config) { MONITOR_CONFIG }
+  let(:driver) { Fluent::Test::Driver::Input.new(Fluent::Plugin::PrometheusMonitorInput).configure(config) }
+
+  describe '#configure' do
+    describe 'valid' do
+      it 'does not raise error' do
+        expect{driver}.not_to raise_error
+      end
+    end
+
+    describe 'invalid' do
+      let(:config) { INVALID_MONITOR_CONFIG }
+      it 'expect raise error' do
+        expect{driver}.to raise_error
+      end
+    end
+  end
+end

data/spec/fluent/plugin/in_prometheus_spec.rb

@@ -0,0 +1,225 @@
+require 'spec_helper'
+require 'fluent/plugin/in_prometheus'
+require 'fluent/test/driver/input'
+
+require 'net/http'
+
+describe Fluent::Plugin::PrometheusInput do
+  CONFIG = %[
+  @type prometheus
+]
+
+  LOCAL_CONFIG = %[
+  @type prometheus
+  bind 127.0.0.1
+]
+
+  let(:config) { CONFIG }
+  let(:port) { 24231 }
+  let(:driver) { Fluent::Test::Driver::Input.new(Fluent::Plugin::PrometheusInput).configure(config) }
+
+  describe '#configure' do
+    describe 'bind' do
+      let(:config) { CONFIG + %[
+  bind 127.0.0.1
+] }
+      it 'should be configurable' do
+        expect(driver.instance.bind).to eq('127.0.0.1')
+      end
+    end
+
+    describe 'port' do
+      let(:config) { CONFIG + %[
+  port 8888
+] }
+      it 'should be configurable' do
+        expect(driver.instance.port).to eq(8888)
+      end
+    end
+
+    describe 'metrics_path' do
+      let(:config) { CONFIG + %[
+  metrics_path /_test
+] }
+      it 'should be configurable' do
+        expect(driver.instance.metrics_path).to eq('/_test')
+      end
+    end
+  end
+
+  describe '#start' do
+    context 'with transport section' do
+      let(:config) do
+        %[
+           @type prometheus
+           bind 127.0.0.1
+           <transport tls>
+             insecure true
+           </transport>
+         ]
+      end
+
+      it 'returns 200' do
+        driver.run(timeout: 1) do
+          Net::HTTP.start('127.0.0.1', port, verify_mode: OpenSSL::SSL::VERIFY_NONE, use_ssl: true) do |http|
+            req = Net::HTTP::Get.new('/metrics')
+            res = http.request(req)
+            expect(res.code).to eq('200')
+          end
+        end
+      end
+    end
+
+    context 'old parameters are given' do
+      context 'when extra_conf is used' do
+        let(:config) do
+          %[
+            @type prometheus
+            bind 127.0.0.1
+            <ssl>
+              enable true
+              extra_conf { "SSLCertName": [["CN", "nobody"], ["DC", "example"]] }
+            </ssl>
+         ]
+        end
+
+        it 'uses webrick' do
+          expect(driver.instance).to receive(:start_webrick).once
+          driver.run(timeout: 1)
+        end
+
+        it 'returns 200' do
+          driver.run(timeout: 1) do
+            Net::HTTP.start('127.0.0.1', port, verify_mode: OpenSSL::SSL::VERIFY_NONE, use_ssl: true) do |http|
+              req = Net::HTTP::Get.new('/metrics')
+              res = http.request(req)
+              expect(res.code).to eq('200')
+            end
+          end
+        end
+      end
+
+      context 'cert_path and private_key_path combination' do
+        let(:config) do
+          %[
+            @type prometheus
+            bind 127.0.0.1
+            <ssl>
+              enable true
+              certificate_path path
+              private_key_path path1
+            </ssl>
+          ]
+        end
+
+        it 'converts them into new transport section' do
+          expect(driver.instance).to receive(:http_server_create_http_server).with(
+                                       :in_prometheus_server,
+                                       addr: anything,
+                                       logger: anything,
+                                       port: anything,
+                                       proto: :tls,
+                                       tls_opts: { 'cert_path' => 'path', 'private_key_path' => 'path1' }
+                                     ).once
+
+          driver.run(timeout: 1)
+        end
+      end
+
+      context 'insecure and ca_path' do
+        let(:config) do
+          %[
+            @type prometheus
+            bind 127.0.0.1
+            <ssl>
+              enable true
+              ca_path path
+            </ssl>
+           ]
+        end
+
+        it 'converts them into new transport section' do
+          expect(driver.instance).to receive(:http_server_create_http_server).with(
+                                       :in_prometheus_server,
+                                       addr: anything,
+                                       logger: anything,
+                                       port: anything,
+                                       proto: :tls,
+                                       tls_opts: { 'ca_path' => 'path', 'insecure' => true }
+                                     ).once
+
+          driver.run(timeout: 1)
+        end
+      end
+
+      context 'when only private_key_path is geven' do
+        let(:config) do
+          %[
+            @type prometheus
+            bind 127.0.0.1
+            <ssl>
+              enable true
+              private_key_path path
+            </ssl>
+           ]
+        end
+
+        it 'raises ConfigError' do
+          expect { driver.run(timeout: 1) }.to raise_error(Fluent::ConfigError, 'both certificate_path and private_key_path must be defined')
+        end
+      end
+    end
+  end
+
+  describe '#run' do
+    context '/metrics' do
+      let(:config) { LOCAL_CONFIG }
+      it 'returns 200' do
+        driver.run(timeout: 1) do
+          Net::HTTP.start("127.0.0.1", port) do |http|
+            req = Net::HTTP::Get.new("/metrics")
+            res = http.request(req)
+            expect(res.code).to eq('200')
+          end
+        end
+      end
+    end
+
+    context '/foo' do
+      let(:config) { LOCAL_CONFIG }
+      it 'does not return 200' do
+        driver.run(timeout: 1) do
+          Net::HTTP.start("127.0.0.1", port) do |http|
+            req = Net::HTTP::Get.new("/foo")
+            res = http.request(req)
+            expect(res.code).not_to eq('200')
+          end
+        end
+      end
+    end
+  end
+
+  describe '#run_multi_workers' do
+    context '/metrics' do
+      Fluent::SystemConfig.overwrite_system_config('workers' => 4) do
+        let(:config) { CONFIG + %[
+          port #{port - 2}
+        ] }
+
+        it 'should configure port using sequential number' do
+          driver = Fluent::Test::Driver::Input.new(Fluent::Plugin::PrometheusInput)
+          driver.instance.instance_eval{ @_fluentd_worker_id = 2 }
+          driver.configure(config)
+          expect(driver.instance.port).to eq(port)
+          driver.run(timeout: 1) do
+            Net::HTTP.start("127.0.0.1", port) do |http|
+              req = Net::HTTP::Get.new("/metrics")
+              res = http.request(req)
+              expect(res.code).to eq('200')
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/fluent/plugin/in_prometheus_tail_monitor_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+require 'fluent/plugin/in_prometheus_tail_monitor'
+require 'fluent/test/driver/input'
+
+describe Fluent::Plugin::PrometheusTailMonitorInput do
+  MONITOR_CONFIG = %[
+  @type prometheus_tail_monitor
+  <labels>
+    host ${hostname}
+    foo bar
+  </labels>
+]
+
+  INVALID_MONITOR_CONFIG = %[
+  @type prometheus_tail_monitor
+
+  <labels>
+    host ${hostname}
+    foo bar
+    invalid_use1 $.foo.bar
+    invalid_use2 $[0][1]
+  </labels>
+]
+
+  let(:config) { MONITOR_CONFIG }
+  let(:driver) { Fluent::Test::Driver::Input.new(Fluent::Plugin::PrometheusTailMonitorInput).configure(config) }
+
+  describe '#configure' do
+    describe 'valid' do
+      it 'does not raise error' do
+        expect { driver }.not_to raise_error
+      end
+    end
+
+    describe 'invalid' do
+      let(:config) { INVALID_MONITOR_CONFIG }
+      it 'expect raise error' do
+        expect { driver }.to raise_error
+      end
+    end
+  end
+end

data/spec/fluent/plugin/out_prometheus_spec.rb

@@ -0,0 +1,166 @@
+require 'spec_helper'
+require 'fluent/test/driver/output'
+require 'fluent/plugin/out_prometheus'
+require_relative 'shared'
+
+describe Fluent::Plugin::PrometheusOutput do
+  let(:tag) { 'prometheus.test' }
+  let(:driver) { Fluent::Test::Driver::Output.new(Fluent::Plugin::PrometheusOutput).configure(config) }
+  let(:registry) { ::Prometheus::Client::Registry.new }
+
+  before do
+    allow(Prometheus::Client).to receive(:registry).and_return(registry)
+  end
+
+  describe '#configure' do
+    it_behaves_like 'output configuration'
+  end
+
+  describe '#run' 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
+
+  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
+
+  describe '#run with retention' do
+    let(:message) { { "foo" => 100, "bar" => 100, "baz" => 100, "qux" => 10 } }
+    let(:labels) { { :bar => 100, :baz => 100, :qux => 10 } }
+
+    context 'config with retention 1' do
+      let(:config) {
+        BASE_CONFIG + %(
+          <metric>
+            name simple
+            type counter
+            desc Something foo.
+            key foo
+            <labels>
+              bar ${bar}
+              baz ${baz}
+              qux ${qux}
+            </labels>
+            retention 1
+            retention_check_interval 1
+          </metric>
+        )
+      }
+
+      it 'expires metric after max 2s' do
+        expect(registry.metrics.map(&:name)).not_to eq([:simple])
+        driver.run(default_tag: tag) {
+          driver.feed(event_time, message)
+          expect(registry.metrics[0].get(labels: labels)).to eq(100)
+          sleep(2)
+          expect(registry.metrics[0].get(labels: labels)).to eq(0.0)
+        }
+      end
+    end
+  end
+
+  describe '#run with topk' do
+    let(:message1) { { "foo" => 200, "bar" => "a" } }
+    let(:message2) { { "foo" => 300, "bar" => "b" } }
+    let(:message3) { { "foo" => 100, "bar" => "c" } }
+
+    context 'config with topk 2' do
+      let(:config) {
+        BASE_CONFIG + %(
+          <metric>
+            name simple
+            type counter
+            desc Something foo.
+            key foo
+            <labels>
+              bar ${bar}
+            </labels>
+            topk 2
+          </metric>
+        )
+      }
+
+      it 'shows only top 2 metrics' do
+        expect(registry.metrics.map(&:name)).not_to eq([:simple])
+        driver.run(default_tag: tag) {
+          driver.feed(event_time, message1)
+          driver.feed(event_time, message2)
+          driver.feed(event_time, message3)
+        }
+        expect(registry.metrics[0].values).to eq({
+                                                   { :bar => "a" } => 200,
+                                                   { :bar => "b" } => 300,
+                                                 })
+      end
+    end
+  end
+
+  describe '#run with reset_after' do
+    let(:message) { { "foo" => 100 } }
+
+    context 'config with reset_after 1' do
+      let(:config) {
+        BASE_CONFIG + %(
+          <metric>
+            name simple
+            type counter
+            desc Something foo.
+            key foo
+            reset_after 1
+          </metric>
+        )
+      }
+
+      it 'resets metric values after max 2s' do
+        expect(registry.metrics.map(&:name)).not_to eq([:simple])
+        driver.run(default_tag: tag) {
+          driver.feed(event_time, message)
+          sleep(2)
+        }
+        expect(registry.metrics[0].values).to eq({ {} => 0 })
+      end
+    end
+  end
+end