twingly-metrics 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c7c23b7fe7fa29534ac78882741d226c25a69629b6520329ae36d489a1ead5cc
+  data.tar.gz: 4750028c638903b62dd13f4911a8d15906accf0c7d7d275f1d46b81064f50858
+SHA512:
+  metadata.gz: 843481f3ac90c856cff73cbb67adcf7be831c4aeabcd7dd41f0b996543bf35aa3519ff8367e24ecbbeee954927be24e141bc87ab1672d92286096a1445a32b2e
+  data.tar.gz: 9b4baf1f630f4e99b6a0118c84325a93b712e9e662d12124c14074da9554be7bdf22925eb434b9c969e8d6094c714a204b06d0235e21eb87e522315fa795d416

data/README.md

@@ -0,0 +1,72 @@
+# Twingly::Metrics
+
+[![GitHub Build Status](https://github.com/twingly/twingly-metrics/workflows/CI/badge.svg)](https://github.com/twingly/twingly-metrics/actions)
+
+A gem for collecting and reporting metrics from our Ruby applications.
+
+This gem currently relies on the [`metriks` gem][metriks] for collecting metrics. The reason for this is that we're already using that gem in our projects. What the `twingly-metrics` gem currently adds in functionality, is the ability to report metrics to [Grafana cloud][grafana-cloud], using their [Graphite HTTP API][grafana-cloud-graphite-api].
+
+The code here was inspired by the reporter in the [`metriks-librato_metrics` gem][metriks-librato_metrics].
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "twingly-metrics"
+```
+
+Or install it yourself as:
+
+```shell
+$ gem install twingly-metrics
+```
+
+## Usage
+
+The following example shows how to use the `Twingly::Metrics::GrafanaCloudReporter` to report metrics to Grafana Cloud using their Graphite HTTP API.
+
+*For more information on the API endpoint and credentials, see the [Grafana Cloud documentation][grafana-cloud-graphite-api].*
+
+```ruby
+require "twingly/metrics"
+
+reporter = Twingly::Metrics::GrafanaCloudReporter.new(
+  endpoint: # The API endpoint of your Grafana Cloud Graphite HTTP API
+            # For example: https://<something>.grafana.net/graphite/metrics
+  user:     # Your Grafana Cloud username for the Graphite HTTP API
+  token:    # Your Grafana Cloud token for the Graphite HTTP API
+
+  prefix:   "my_app",            # Optional, can be used to add a prefix to all reported metrics,
+                                 # for example the name of your application
+  source:   "some-example-host", # Optional, can be used for adding a "source" tag to all reported metrics,
+                                 # useful for separating metrics by host
+
+  logger:  Logger.new(STDOUT),   # Optional, a logger to log any errors raised in the reporter
+
+  # See the reporter class for more options
+)
+
+reporter.start # Starts the reporter thread in the background
+
+# Create some metrics for the reporter to have something to report
+Metriks.meter("test.meter").mark(1)
+
+at_exit do
+  reporter.flush # Ensure all unreported metrics are sent before exiting
+end
+```
+
+### Supported metric types
+
+The reporter currently supports the following metric types from the `metriks` gem:
+
+* [`Metriks.counter`](https://github.com/eric/metriks?tab=readme-ov-file#counters)
+* [`Metriks.gauge`](https://github.com/eric/metriks?tab=readme-ov-file#gauges)
+* [`Metriks.meter`](https://github.com/eric/metriks?tab=readme-ov-file#meters)
+* [`Metriks.timer`](https://github.com/eric/metriks?tab=readme-ov-file#timers)
+
+[metriks]: https://github.com/eric/metriks
+[grafana-cloud]: https://grafana.com/products/cloud/
+[grafana-cloud-graphite-api]: https://grafana.com/docs/grafana-cloud/send-data/metrics/metrics-graphite/http-api/#adding-new-data-posting-to-metrics
+[metriks-librato_metrics]: https://github.com/eric/metriks-librato_metrics

data/lib/twingly/metrics/grafana_cloud_reporter.rb

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+require "net/https"
+require "json"
+require "metriks"
+
+module Twingly
+  module Metrics
+    class GrafanaCloudReporter # rubocop:disable Metrics/ClassLength
+      class Error < StandardError; end
+      class UnsupportedMetricError < Error; end
+
+      class RequestFailedError < Error
+        attr_reader :request, :response, :data
+
+        def initialize(request, response, data = nil)
+          super()
+
+          @request  = request
+          @response = response
+          @data     = data
+        end
+
+        def to_s
+          "#{response.code} #{response.message.dump}"
+        end
+      end
+
+      METRIC_TYPE_TO_BUILD_METHOD = {
+        Metriks::Meter   => :build_meter_metric,
+        Metriks::Counter => :build_counter_metric,
+        Metriks::Gauge   => :build_gauge_metric,
+        Metriks::Timer   => :build_timer_metric,
+      }.freeze
+
+      attr_reader :endpoint
+      attr_reader :user
+      attr_reader :token
+      attr_reader :prefix
+      attr_reader :source
+      attr_reader :logger
+      attr_reader :registry
+      attr_reader :interval
+      attr_reader :timeout
+
+      def initialize(endpoint:, user:, token:, **options) # rubocop:disable Metriks/AbcSize, Metrics/MethodLength
+        @endpoint = endpoint
+        @user     = user
+        @token    = token
+
+        @prefix = options[:prefix]
+        @source = options[:source]
+        @logger = options[:logger]
+
+        @registry = options[:registry] || Metriks::Registry.default
+        @interval = options[:interval] || 60
+        @on_error = options[:on_error] || proc { |ex| @logger&.error(ex) }
+        @timeout  = options[:timeout]  || 10
+
+        @next_time = Time.now.to_f
+
+        @previous_request_values = Hash.new { |h, k| h[k] = 0 }
+
+        @percentiles = options[:percentiles] || [0.95, 0.999]
+
+        @flush_metrics_mutex = Mutex.new
+        @running             = false
+        @reporter_thread     = nil
+      end
+
+      def start
+        return if @reporter_thread&.alive?
+
+        @running = true
+        @reporter_thread = Thread.new do
+          while @running
+            sleep_until_next_flush
+
+            Thread.new do
+              flush
+            end
+          end
+        end
+      end
+
+      def stop
+        @running = false
+
+        return unless @reporter_thread
+
+        @reporter_thread.join
+        @reporter_thread = nil
+      end
+
+      def restart
+        stop
+        start
+      end
+
+      def flush
+        @flush_metrics_mutex.synchronize do
+          request_data = build_metrics_data_for_request
+
+          make_request(request_data)
+        end
+      rescue StandardError => e
+        @on_error.call(e)
+      end
+
+      private
+
+      def make_request(request_data) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        return if request_data.empty?
+
+        url                   = URI.parse(@endpoint)
+        request               = Net::HTTP::Post.new(url.path)
+        request.basic_auth(@user, @token)
+        request.body          = request_data.to_json
+        request.content_type  = "application/json"
+
+        http              = Net::HTTP.new(url.host, url.port)
+        http.verify_mode  = OpenSSL::SSL::VERIFY_PEER
+        http.use_ssl      = true
+        http.open_timeout = @timeout
+        http.read_timeout = @timeout
+
+        case response = http.start { |http| http.request(request) }
+        when Net::HTTPSuccess, Net::HTTPRedirection
+          # OK
+        else
+          raise RequestFailedError.new(request, response, request_data.dup)
+        end
+      end
+
+      def build_metrics_data_for_request
+        time = now_floored
+
+        request_data = @registry.each.map do |name, metric|
+          next if name.nil? || name.empty?
+
+          metric_method = METRIC_TYPE_TO_BUILD_METHOD.fetch(metric.class) do
+            handle_unsupported_metric(name, metric)
+          end
+
+          next unless metric_method
+
+          send(metric_method, name, metric, time)
+        end
+
+        request_data.compact.flatten
+      end
+
+      def handle_unsupported_metric(name, metric)
+        error = UnsupportedMetricError.new("Unsupported metric type: #{metric.class.name} for metric '#{name}'")
+        @on_error.call(error)
+      end
+
+      def build_meter_metric(name, metric, time)
+        current_count = metric.count
+        previous_count = @previous_request_values[name]
+
+        @previous_request_values[name] = current_count
+
+        build_grafana_metric(name, current_count - previous_count, time)
+      end
+
+      def build_counter_metric(name, metric, time)
+        build_grafana_metric(name, metric.count, time)
+      end
+
+      def build_gauge_metric(name, metric, time)
+        build_grafana_metric(name, metric.value, time)
+      end
+
+      def build_timer_metric(name, metric, time)
+        [].tap do |time_metrics|
+          previous_count = @previous_request_values[name]
+          current_count = metric.count
+          @previous_request_values[name] = current_count
+
+          time_metrics << build_grafana_metric("#{name}.count", current_count - previous_count, time)
+
+          snapshot = metric.snapshot
+
+          time_metrics << build_grafana_metric("#{name}.median", snapshot.median, time)
+
+          build_timer_metric_percentiles(name, snapshot, time) { |metric| time_metrics << metric }
+        end
+      end
+
+      def build_timer_metric_percentiles(name, snapshot, time)
+        @percentiles.each do |percentile|
+          percentile_name = percentile_to_metric_name(percentile)
+
+          yield build_grafana_metric("#{name}.#{percentile_name}", snapshot.value(percentile), time)
+        end
+      end
+
+      def percentile_to_metric_name(percentile)
+        number = (percentile * 100).to_f.to_s.gsub(/0+$/, "").gsub(".", "")
+
+        "#{number}th_percentile"
+      end
+
+      def build_grafana_metric(name, value, time)
+        name = "#{prefix}.#{name}" if prefix
+
+        graphite_data = {
+          name:     name,
+          interval: @interval,
+          value:    value,
+          time:     time.to_i,
+        }
+
+        graphite_data[:tags] = ["source=#{@source}"] unless @source.to_s.empty?
+
+        graphite_data
+      end
+
+      def sleep_until_next_flush
+        sleep_time = next_time - Time.now.to_f
+
+        return if sleep_time <= 0
+
+        sleep sleep_time
+      end
+
+      def now_floored
+        time = Time.now.to_i
+        time - (time % @interval)
+      end
+
+      def next_time
+        now = Time.now.to_f
+        @next_time = now if @next_time <= now
+        @next_time += @interval - (@next_time % @interval)
+      end
+    end
+  end
+end

data/lib/twingly/metrics/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Twingly
+  module Metrics
+    VERSION = "0.1.0"
+  end
+end

data/lib/twingly/metrics.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative "metrics/version"
+require_relative "metrics/grafana_cloud_reporter"

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: twingly-metrics
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Twingly AB
+bindir: bin
+cert_chain: []
+date: 2025-07-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: metriks
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+description: Collect and report metrics in Ruby applications, and report them to Graphite.
+email:
+- support@twingly.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/twingly/metrics.rb
+- lib/twingly/metrics/grafana_cloud_reporter.rb
+- lib/twingly/metrics/version.rb
+homepage: https://github.com/twingly/twingly-metrics
+licenses: []
+metadata:
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.5
+specification_version: 4
+summary: Ruby library for collecting and reporting metrics.
+test_files: []