prometheus_exporter 0.3.3 → 0.3.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 884ad6656dc8d2b784711db6e057cf9743cc93a4bb7d9bc978b06e90441978a1
-  data.tar.gz: 34fbcbba98564562c49ea99dcffa95403224d6c85f372686426bed005d5a64e2
+  metadata.gz: 7725cb2b5d8846c874cd69d2ce92ca7a7fd2859ce9e6babe8cc86e96db9e3f2b
+  data.tar.gz: c08f9d1a4b18733c9a1c8882453bc40ffb7347ac5a71ccc972500334245aecba
 SHA512:
-  metadata.gz: 243a116fd665dea9bb6b9ed2d350a07a3819b512be4320993caa4b3a1038987c9232b325ff605f9495b75c33626dab2a0ba56d7fd6b0f3119d23156086391c72
-  data.tar.gz: 26630637bbcbfcd92d5c3ec3ccef0ffe9e88b1d8822e2df7c1e76aef9c0ae2bae730e4f6125dd9d169679cb8336f03e6129f0eeb7f2f6ad7e0aa6d3ec886c8aa
+  metadata.gz: 436ad9dcd8248147fb13ba1f0fc3d2e0b1badc113c41bc7ead07c560f984f32b7caa72fd4cfa1162209b525319574cfb962dff9dd092c2557fca39df2fbe1a8c
+  data.tar.gz: 9365bea75c02bc742514058cd7d66c077a8b0d49ce941a5067887cacd6a051ca28f86870c4456579f16101e98ea4d70733c08e8f9924ff8dead52be4b2c01d91

data/CHANGELOG

@@ -1,3 +1,7 @@
+0.3.4 - 02-10-2018
+
+- Fix: custom collector via CLI was not working correctly
+
 0.3.3
 
 - Feature: Add more metrics to delayed job collector

data/README.md

@@ -1,8 +1,32 @@
 # Prometheus Exporter
 
-Prometheus Exporter allows you to aggregate custom metrics from multiple processes and export to Prometheus.
+Prometheus Exporter allows you to aggregate custom metrics from multiple processes and export to Prometheus. It provides a very flexible framework for handling Prometheus metrics and can operate in a single and multiprocess mode.
+
+To learn more see [Instrumenting Rails with Prometheus](https://samsaffron.com/archive/2018/02/02/instrumenting-rails-with-prometheus) (it has pretty pictures!)
+
+* [Requirements](#requirements)
+* [Installation](#installation)
+* [Usage](#usage)
+  * [Single process mode](#single-process-mode)
+  * [Multi process mode](#multi-process-mode)
+  * [Rails integration](#rails-integration)
+    * [Per-process stats](#per-process-stats)
+    * [Sidekiq metrics](#sidekiq-metrics)
+    * [Delayed Job plugin](#delayed-job-plugin)
+  * [Custom type collectors](#custom-type-collectors)
+  * [Multi process mode with custom collector](#multi-process-mode-with-custom-collector)
+  * [GraphQL support](#graphql-support)
+  * [Metrics default prefix / labels](#metrics-default-prefix--labels)
+  * [Client default labels](#client-default-labels)
+* [Transport concerns](#transport-concerns)
+* [JSON generation and parsing](#json-generation-and-parsing)
+* [Contributing](#contributing)
+* [License](#license)
+* [Code of Conduct](#code-of-conduct)
+
+## Requirements
 
-It provides a very flexible framework for handling Prometheus metrics and can operate in a single and multiprocess mode.
+Minimum Ruby of version 2.3.0 is required, Ruby 2.2.0 is EOL as of 2018-03-31
 
 ## Installation
 
@@ -20,19 +44,11 @@ Or install it yourself as:
 
     $ gem install prometheus_exporter
 
-## Ruby Version
-
-Minimum Ruby of version 2.3.0 is required, Ruby 2.2.0 is EOL as of 2018-03-31
-
-## Can I have some pretty pictures please?
-
-Sure, check out: [Instrumenting Rails with Prometheus](https://samsaffron.com/archive/2018/02/02/instrumenting-rails-with-prometheus)
-
 ## Usage
 
 ### Single process mode
 
-Simplest way of consuming Prometheus exporter is in a single process mode, to do so:
+Simplest way of consuming Prometheus exporter is in a single process mode.
 
 ```ruby
 require 'prometheus_exporter/server'
@@ -65,19 +81,17 @@ summary.observe(0.12)
 
 ### Multi process mode
 
-In some cases, for example unicorn or puma clusters you may want to aggregate metrics across multiple processes.
+In some cases (for example, unicorn or puma clusters) you may want to aggregate metrics across multiple processes.
 
-Simplest way to acheive this is use the built-in collector.
+Simplest way to achieve this is to use the built-in collector.
 
-First, run an exporter on your desired port, we use the default port of 9394:
+First, run an exporter on your desired port (we use the default port of 9394):
 
 ```
-# prometheus_exporter
+$ prometheus_exporter
 ```
 
-At this point an exporter is running on port 9394
-
-In your application:
+And in your application:
 
 ```ruby
 require 'prometheus_exporter/client'
@@ -92,8 +106,8 @@ gauge.observe(99, day: "friday")
 
 Then you will get the metrics:
 
-```bash
-% curl localhost:9394/metrics
+```
+$ curl localhost:9394/metrics
 # HELP collector_working Is the master process collector able to collect metrics
 # TYPE collector_working gauge
 collector_working 1
@@ -105,20 +119,18 @@ awesome 10
 
 ```
 
-### Easy integration into Rails
+### Rails integration
 
-You can easily integrate into any Rack application:
+You can easily integrate into any Rack application.
 
 In your Gemfile:
 
-```
+```ruby
 gem 'prometheus_exporter'
 ```
 
-
+In an initializer:
 ```ruby
-# in an initializer
-
 unless Rails.env == "test"
   require 'prometheus_exporter/middleware'
 
@@ -127,7 +139,15 @@ unless Rails.env == "test"
 end
 ```
 
-You may also be interested in per-process stats, this collects memory and GC stats
+Ensure you run the exporter in a monitored background process:
+
+```
+$ bundle exec prometheus_exporter
+```
+
+#### Per-process stats
+
+You may also be interested in per-process stats. This collects memory and GC stats:
 
 ```ruby
 # in an initializer
@@ -146,6 +166,8 @@ end
 
 ```
 
+#### Sidekiq metrics
+
 Including Sidekiq metrics (how many jobs ran? how many failed? how long did they take?)
 
 ```ruby
@@ -157,7 +179,7 @@ Sidekiq.configure_server do |config|
 end
 ```
 
-To monitor Sidekiq process info
+To monitor Sidekiq process info:
 
 ```ruby
 Sidekiq.configure_server do |config|
@@ -168,25 +190,20 @@ Sidekiq.configure_server do |config|
 end
 ```
 
-It also comes with a DelayedJob plugin.
+#### Delayed Job plugin
+
+In an initializer:
 
 ```ruby
-# in an initializer
 unless Rails.env == "test"
   require 'prometheus_exporter/instrumentation'
   PrometheusExporter::Instrumentation::DelayedJob.register_plugin
 end
 ```
 
-Ensure you run the exporter in a monitored background process via
-
-```
-% bundle exec prometheus_exporter
-```
-
 #### Instrumenting Request Queueing Time
 
-Request Queueing is defined as the time it takes for a request to reach your application (instrumented by this `prometheus_exporter`) from farther upstream (as your load balancer). A high queueing time usually means that your backend cannot handle all the incoming requests in time, so they queue up (= you should see if you need to add more capacity)
+Request Queueing is defined as the time it takes for a request to reach your application (instrumented by this `prometheus_exporter`) from farther upstream (as your load balancer). A high queueing time usually means that your backend cannot handle all the incoming requests in time, so they queue up (= you should see if you need to add more capacity).
 
 As this metric starts before `prometheus_exporter` can handle the request, you must add a specific HTTP header as early in your infrastructure as possible (we recommend your load balancer or reverse proxy).
 
@@ -196,7 +213,7 @@ Hint: we aim to be API-compatible with the big APM solutions, so if you've got r
 
 ### Custom type collectors
 
-In some cases you may have custom metrics you want to ship the collector in a batch, in this case you may still be interested in the base collector behavior but would like to add your own special messages.
+In some cases you may have custom metrics you want to ship the collector in a batch. In this case you may still be interested in the base collector behavior, but would like to add your own special messages.
 
 ```ruby
 # person_collector.rb
@@ -226,7 +243,7 @@ end
 
 Shipping metrics then is done via:
 
-```
+```ruby
 PrometheusExporter::Client.default.send_json(type: "person", age: 40)
 ```
 
@@ -234,15 +251,14 @@ To load the custom collector run:
 
 
 ```
-bundle exec prometheus_exporter -a person_collector.rb
-
+$ bundle exec prometheus_exporter -a person_collector.rb
 ```
 
 #### Global metrics in a custom type collector
 
-Custom type collectors are the ideal place to collect global metrics, such as user/article counts and connection counts. The custom type collector runs in the collector which usually runs in the prometheus exporter process.
+Custom type collectors are the ideal place to collect global metrics, such as user/article counts and connection counts. The custom type collector runs in the collector, which usually runs in the prometheus exporter process.
 
-Out-of-the-box we try to keep the prometheus exporter as lean as possible, we do not load all the Rails dependencies so you will not have access to your models. You can always ensure it is loaded in your custom type collector with:
+Out-of-the-box we try to keep the prometheus exporter as lean as possible. We do not load all Rails dependencies, so you won't have access to your models. You can always ensure it is loaded in your custom type collector with:
 
 ```ruby
 unless defined? Rails
@@ -260,8 +276,7 @@ def metrics
 end
 ```
 
-The metrics endpoint is called whenever prometheus calls the `/metrics` HTTP endpoint, it may make sense to introduce some caching so database calls are only performed once every N seconds. [lru_redux](https://github.com/SamSaffron/lru_redux) is the perfect gem for that kind of job as you can `LruRedux::TTL::Cache` which will automatically expire after N seconds.
-
+The metrics endpoint is called whenever prometheus calls the `/metrics` HTTP endpoint, so it may make sense to introduce some type of caching. [lru_redux](https://github.com/SamSaffron/lru_redux) is the perfect gem for this job: you can use `LruRedux::TTL::Cache`, which will expire automatically after N seconds, thus saving multiple database queries.
 
 ### Multi process mode with custom collector
 
@@ -269,7 +284,7 @@ You can opt for custom collector logic in a multi process environment.
 
 This allows you to completely replace the collector logic.
 
-First, define a custom collector, it is critical you inherit off `PrometheusExporter::Server::Collector`, also it is critical you have custom implementations for #process and #prometheus_metrics_text
+First, define a custom collector. It is important that you inherit off `PrometheusExporter::Server::CollectorBase` and have custom implementations for `#process` and `#prometheus_metrics_text` methods.
 
 ```ruby
 class MyCustomCollector < PrometheusExporter::Server::CollectorBase
@@ -302,11 +317,11 @@ end
 
 Next, launch the exporter process:
 
-```bash
-% bin/prometheus_exporter --collector examples/custom_collector.rb
+```
+$ bin/prometheus_exporter --collector examples/custom_collector.rb
 ```
 
-In your application ship it the metrics you want:
+In your application send metrics you want:
 
 ```ruby
 require 'prometheus_exporter/client'
@@ -319,7 +334,7 @@ client.send_json(thing2: 12)
 Now your exporter will echo the metrics:
 
 ```
-% curl localhost:12345/metrics
+$ curl localhost:12345/metrics
 # HELP collector_working Is the master process collector able to collect metrics
 # TYPE collector_working gauge
 collector_working 1
@@ -335,15 +350,13 @@ thing2 12
 
 ### GraphQL support
 
-GraphQL execution metrics are [supported](https://github.com/rmosolgo/graphql-ruby/blob/master/guides/queries/tracing.md#prometheus) and can be collected via the GraphQL
-collector, included in [graphql-ruby](https://github.com/rmosolgo/graphql-ruby)
-
+GraphQL execution metrics are [supported](https://github.com/rmosolgo/graphql-ruby/blob/master/guides/queries/tracing.md#prometheus) and can be collected via the GraphQL collector, included in [graphql-ruby](https://github.com/rmosolgo/graphql-ruby).
 
 ### Metrics default prefix / labels
 
-_This only works in single process mode_
+_This only works in single process mode._
 
-You can specify default prefix or labels for metrics, for example:
+You can specify default prefix or labels for metrics. For example:
 
 ```ruby
 # Specify prefix for metric names
@@ -369,7 +382,7 @@ ruby_web_requests{hostname="app-server-01"} 1
 
 ### Client default labels
 
-You can specify a default label for the instrumentation metrics sent by an specific client, for example:
+You can specify a default label for instrumentation metrics sent by a specific client. For example:
 
 ```ruby
 # Specify on intializing PrometheusExporter::Client
@@ -389,15 +402,15 @@ http_requests_total{service="app-server-01",app_name="app-01"} 1
 
 ## Transport concerns
 
-Prometheus Exporter handles transport using a simple HTTP protocol. In multi process mode we avoid needing a large number of HTTP request by using chunked encoding to send metrics. This means that a single HTTP channel can deliver 100s or even 1000s of metrics over a single HTTP session to the `/send-metrics` endpoint. All calls to `send` and `send_json` on the PrometheusExporter::Client class are **non-blocking** and batched.
+Prometheus Exporter handles transport using a simple HTTP protocol. In multi process mode we avoid needing a large number of HTTP request by using chunked encoding to send metrics. This means that a single HTTP channel can deliver 100s or even 1000s of metrics over a single HTTP session to the `/send-metrics` endpoint. All calls to `send` and `send_json` on the `PrometheusExporter::Client` class are **non-blocking** and batched.
 
-The `/bench` directory has simple benchmark it is able to send through 10k messages in 500ms.
+The `/bench` directory has simple benchmark, which is able to send through 10k messages in 500ms.
 
 ## JSON generation and parsing
 
-The `PrometheusExporter::Client` class has the method `#send-json`. This method, by default, will call `JSON.dump` on the Object it recieves. You may opt in for `oj` mode where it can use the faster `Oj.dump(obj, mode: :compat)` for JSON serialization. But be warned that if you have custom objects that implement own `to_json` methods this may not work as expected. You can opt for oj serialization with `json_serializer: :oj`
+The `PrometheusExporter::Client` class has the method `#send-json`. This method, by default, will call `JSON.dump` on the Object it recieves. You may opt in for `oj` mode where it can use the faster `Oj.dump(obj, mode: :compat)` for JSON serialization. But be warned that if you have custom objects that implement own `to_json` methods this may not work as expected. You can opt for oj serialization with `json_serializer: :oj`.
 
-The `PrometheusExporter::Server::Collector` parses your JSON, by default it will use the faster Oj deserializer if availabe. This happens cause it only expects a simple Hash out of the box. You can opt in for the default JSON deserializer with `json_serializer: :json`
+When `PrometheusExporter::Server::Collector` parses your JSON, by default it will use the faster Oj deserializer if available. This happens cause it only expects a simple Hash out of the box. You can opt in for the default JSON deserializer with `json_serializer: :json`.
 
 ## Contributing
 
@@ -409,4 +422,4 @@ The gem is available as open source under the terms of the [MIT License](https:/
 
 ## Code of Conduct
 
-Everyone interacting in the PrometheusExporter project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/SamSaffron/prometheus_exporter/blob/master/CODE_OF_CONDUCT.md).
+Everyone interacting in the PrometheusExporter project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/discourse/prometheus_exporter/blob/master/CODE_OF_CONDUCT.md).

data/bin/prometheus_exporter

@@ -48,6 +48,7 @@ def run
     ObjectSpace.each_object(Class) do |klass|
       if klass < base_klass && klass != base_klass
         options[:collector_class] = klass
+        found = true
       end
     end
 

data/lib/prometheus_exporter/client.rb

@@ -13,15 +13,30 @@ class PrometheusExporter::Client
       @type = type
     end
 
-    def observe(value = 1, keys = nil)
-      @client.send_json(
+    def standard_values(value, keys, prometheus_exporter_action = nil)
+      values = {
         type: @type,
         help: @help,
         name: @name,
         keys: keys,
         value: value
-      )
+      }
+      values[:prometheus_exporter_action] = prometheus_exporter_action if prometheus_exporter_action
+      values
     end
+
+    def observe(value = 1, keys = nil)
+      @client.send_json(standard_values(value, keys))
+    end
+
+    def increment(keys = nil, value = 1)
+      @client.send_json(standard_values(value, keys, :increment))
+    end
+
+    def decrement(keys = nil, value = 1)
+      @client.send_json(standard_values(value, keys, :decrement))
+    end
+
   end
 
   def self.default

data/lib/prometheus_exporter/metric/gauge.rb

@@ -22,5 +22,15 @@ module PrometheusExporter::Metric
     def observe(value, labels = {})
       @data[labels] = value
     end
+
+    def increment(labels = {}, value = 1)
+      @data[labels] ||= 0
+      @data[labels] += value
+    end
+
+    def decrement(labels = {}, value = 1)
+      @data[labels] ||= 0
+      @data[labels] -= value
+    end
   end
 end

data/lib/prometheus_exporter/server/collector.rb

@@ -46,7 +46,14 @@ module PrometheusExporter::Server
           if !metric
             metric = register_metric_unsafe(obj)
           end
-          metric.observe(obj["value"], obj["keys"])
+          case obj["prometheus_exporter_action"]
+          when 'increment'
+            metric.increment(obj["keys"], obj["value"])
+          when 'decrement'
+            metric.decrement(obj["keys"], obj["value"])
+          else
+            metric.observe(obj["value"], obj["keys"])
+          end
         end
       end
     end

data/lib/prometheus_exporter/version.rb

@@ -1,3 +1,3 @@
 module PrometheusExporter
-  VERSION = "0.3.3"
+  VERSION = "0.3.4"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: prometheus_exporter
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.3.4
 platform: ruby
 authors:
 - Sam Saffron
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-07-27 00:00:00.000000000 Z
+date: 2018-10-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler