autometrics 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 21d41e117081d9491015d27d01e7b4c958c5118487f4eeb49d1aa5e5b7f50226
+  data.tar.gz: f77d2f58af4ec3ba0608d5fae471240c569b993050d0e72072306a0a024df074
+SHA512:
+  metadata.gz: 8c553bd576b0eeec75da64346d5c79dfb84fe2a0007cc9d1209db2887a21c06dbca8c33d108e0c24843a2be6a4e42f309204a1047300ad3fe6528d9b995c9d5d
+  data.tar.gz: 7c921566a8756de4d04d588238e57e40002b5065961c1620625a8bc93e0838ee311fd21b2b68a00a026703c5f705735af1967b2d2fcdbc6dd06ae6c2d66b73b1

data/.gitignore

@@ -0,0 +1,56 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+# Used by dotenv library to load environment variables.
+# .env
+
+# Ignore Byebug command history file.
+.byebug_history
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+*.bridgesupport
+build-iPhoneOS/
+build-iPhoneSimulator/
+
+## Specific to RubyMotion (use of CocoaPods):
+#
+# We recommend against adding the Pods directory to your .gitignore. However
+# you should judge for yourself, the pros and cons are mentioned at:
+# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
+#
+# vendor/Pods/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+
+# Used by RuboCop. Remote config files pulled in from inherit_from directive.
+# .rubocop-https?--*

data/Gemfile

@@ -0,0 +1,11 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+group :development, :test do
+  gem 'byebug'
+  gem 'bundler-audit'
+end
+
+# Specify gem's dependencies in autometrics.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,27 @@
+PATH
+  remote: .
+  specs:
+    autometrics (0.0.1)
+      prometheus-client
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    bundler-audit (0.9.1)
+      bundler (>= 1.2.0, < 3)
+      thor (~> 1.0)
+    byebug (11.1.3)
+    prometheus-client (4.0.0)
+    thor (1.2.1)
+
+PLATFORMS
+  arm64-darwin-21
+
+DEPENDENCIES
+  autometrics!
+  bundler (~> 2.3)
+  bundler-audit
+  byebug
+
+BUNDLED WITH
+   2.4.6

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Autometrics
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,95 @@
+# autometrics-ruby
+
+> :warning: **Autometrics for Ruby is under active development.** We are seeking feedback from the community on the API and implementation. Please open an issue if you have any questions or feedback!
+
+A Ruby module that makes it easy to understand the error rate, response time, and production usage of any function in your code.
+
+Once complete, you should only have to add a one or two lines of code, and then be able to jump straight from your IDE to live Prometheus charts for each of your HTTP/RPC handlers, database methods, or any other piece of application logic.
+
+## Features
+
+- ✨ `include Autometrics` exposes utilities that can instrument class methods, in order to track useful metrics for your application
+- ⚡ Minimal runtime overhead
+
+**Coming Soon**
+
+- 💡 Writes Prometheus queries so you can understand the data generated without knowing PromQL
+- 🔗 Create links to live Prometheus charts directly into each function's docstrings, via SolarGraph
+
+- 📊 Grafana dashboard showing the performance of all instrumented functions
+
+## Usage
+
+Autometrics makes use of `"prometheus-client"` under the hood, which is the aptly named Ruby client for Prometheus.
+
+For now, you simply need to add the autometrics gem to your project, `include Autometrics` in any class you wish to observe, and then set up a `/metrics` endpoint in your app that exposes the metrics to Prometheus, if one does not already exist.
+
+### Usage inside a class
+
+```ruby
+# Include the `Autometrics` module, then call `autometrics` to enable autometrics on specific methods
+
+class ClassWithSomeAutometrics
+  include Autometrics
+
+  # Option 1: Specify an allow-list of the methods to observe
+  autometrics only: :foo
+
+  # Option 2: Provide an exclusion-list of the methods we should not observe
+  autometrics skip: :bar
+
+  def foo
+    p "I'm getting observed!"
+  end
+
+  def bar
+    p "I am not getting observed. :("
+  end
+end
+
+# Include `Autometrics::On` to enable autometrics on all methods (`initialize` is excluded by default)
+class ClassWithAllAutometrics
+  include Autometrics::On
+
+  def foo
+    p "This will be observed in prometheus!"
+  end
+
+  def bar
+    p "Sooøøøoo will this!"
+  end
+end
+```
+
+### Usage with plain-old Ruby methods
+
+```ruby
+require "autometrics"
+
+autometrics def top_level_foo
+  p "I'm getting observed!"
+end
+```
+
+## TODOs
+
+- [ ] Provide an example of how to use Autometrics with a Rails app
+- [ ] Look for other methods to exclude by default, like `initialize`. (E.g., should we exclude private methods?)
+- [ ] Add tests
+- [ ] Investigate ability to swap out the prometheus client, e.g., using the [`prometheus_exporter` gem](https://github.com/discourse/prometheus_exporter)
+
+## Developing Locally
+
+To build the Gem:
+
+```sh
+gem build autometrics.gemspec
+```
+
+For a simple smoke test, run `bundle` and `bundle exec ruby autometrics_test_quick.rb`.
+
+To use debug logs:
+
+```sh
+LOG_LEVEL=debug bundle exec ruby autometrics_test_quick.rb
+```

data/autometrics.gemspec

@@ -0,0 +1,33 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'autometrics/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'autometrics'
+  spec.version = Autometrics::VERSION
+  spec.authors = ['Brett Beutell']
+  spec.email = ['brett@fiberplane.com']
+
+  spec.summary =
+    'Ruby implmentation of autometrics library'
+  spec.description =
+    'Add developer-friendly observability to your Ruby code with minimal setup'
+  spec.homepage = 'https://github.com/autometrics-dev/autometrics-ruby'
+  spec.license = 'MIT'
+
+  spec.files =
+    `git ls-files -z`.split("\x0").reject do |f|
+      f.match(%r{^(assets|test|spec|features)/})
+    end
+  # TODO - figure out what bindir does
+  # spec.bindir = 'exe'
+  spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 2.3'
+  # spec.add_development_dependency 'rake', '~> 12.3.3'
+  # spec.add_development_dependency 'rspec', '~> 3.0'
+
+  # TODO - pin version
+  spec.add_dependency 'prometheus-client'
+end

data/autometrics_test_quick.rb

@@ -0,0 +1,52 @@
+require_relative 'lib/autometrics'
+
+# A class that has autometrics off by default
+class ClassWithNoAutometrics
+  include Autometrics
+
+  # Uncomment this line to turn on autometrics for this class
+  # autometrics
+
+  def instance_method_of_class
+    p "[instance_method_of_class] You should see no [autometrics] around this function call"
+  end
+
+  def another_instance_method_of_class
+    p "[another_instance_method_of_class] You should see no [autometrics] around this function call"
+  end
+end
+
+class_with_none = ClassWithNoAutometrics.new
+class_with_none.instance_method_of_class
+class_with_none.another_instance_method_of_class
+
+module AutometricsTest
+  class ClassWithSomeAutometrics
+    include Autometrics::On
+
+    autometrics only: :foo
+
+    def foo
+      p "`foo` here! You should see some [autometrics::foo] logs around me"
+    end
+
+    def bar
+      p "`bar` here! You shouldn't see any [autometrics::bar] logs by me"
+    end
+  end
+end
+
+class_with_some = AutometricsTest::ClassWithSomeAutometrics.new
+class_with_some.foo
+class_with_some.bar
+
+
+autometrics def bare_function
+  puts "[bare_function] You should see [self.autometrics] around this function call"
+end
+
+bare_function
+
+puts "*****"
+puts "Now let's check the metrics we've collected"
+puts Autometrics::PROMETHEUS.test_get_values({ function: :bare_function, module: '' })

data/examples/autometrics-sinatra-example/.gitignore

@@ -0,0 +1,2 @@
+# Project specific
+votes.yml

data/examples/autometrics-sinatra-example/Gemfile

@@ -0,0 +1,16 @@
+source 'https://rubygems.org'
+
+gem 'autometrics', path: '../../'
+
+gem 'puma'
+gem 'sinatra'
+gem 'yaml'
+
+group :development, :test do
+  gem 'byebug', '~> 11.1'
+  # NOTE - Uncomment to use local solargraph gem(s)
+  #        This is useful for testing integrated documentation functionality (still WIP)
+  #
+  # gem 'solargraph', path: '../../path/to/solargraph'
+  # gem 'solargraph-autometrics', path: '../../path/to/solargraph-autometrics'
+end

data/examples/autometrics-sinatra-example/Gemfile.lock

@@ -0,0 +1,40 @@
+PATH
+  remote: ../..
+  specs:
+    autometrics (0.0.1)
+      prometheus-client
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    byebug (11.1.3)
+    mustermann (3.0.0)
+      ruby2_keywords (~> 0.0.1)
+    nio4r (2.5.8)
+    prometheus-client (4.0.0)
+    puma (5.6.5)
+      nio4r (~> 2.0)
+    rack (2.2.6.2)
+    rack-protection (3.0.5)
+      rack
+    ruby2_keywords (0.0.5)
+    sinatra (3.0.5)
+      mustermann (~> 3.0)
+      rack (~> 2.2, >= 2.2.4)
+      rack-protection (= 3.0.5)
+      tilt (~> 2.0)
+    tilt (2.1.0)
+    yaml (0.2.1)
+
+PLATFORMS
+  arm64-darwin-21
+
+DEPENDENCIES
+  autometrics!
+  byebug (~> 11.1)
+  puma
+  sinatra
+  yaml
+
+BUNDLED WITH
+   2.4.6

data/examples/autometrics-sinatra-example/README.md

@@ -0,0 +1,40 @@
+# Autometrics Sinatra Example
+
+This project contains a simple Sinatra app that can be used to test the Autometrics library.
+
+Here, we're using autometrics in the `db.rb` module, in order to generate metrics for our database calls.
+
+## App Overview
+
+> Example code adatped from https://guides.railsgirls.com/sinatra-app
+
+The app itself is a JSON api that can record vote tallies. To make things concrete, we'll say we're voting on pizza toppings.
+
+There is a `POST /cast` endpoint that accepts a `vote` parameter. The value of the `vote` parameter is the name of a pizza topping. The endpoint will increment the vote count for that topping.
+
+There is a `GET /results` endpoint that returns a JSON object with the current vote tallies.
+
+There is a simple database module in `db.rb` that provides methods for storing votes and retrieving vote tallies. The "database" is really just a local yaml file.
+
+In this example, we generate metrics for our "database" calls, and expose the metrics to prometheus on the `/metrics` endpoint, which is set up in `suffragist.rb`. (See the line `use Prometheus::Middleware::Exporter`.)
+
+## Usage
+
+Test the API
+
+```sh
+# Install dependencies
+bundle install
+
+# Start server
+bundle exec ruby suffragist.rb
+
+# Vote for a pizza topping
+curl -XPOST "http://localhost:4567/cast?vote=mushroom"
+
+# See votes
+curl localhost:4567/results
+
+# View metrics (these would be scraped by prometheus)
+curl localhost:4567/metrics
+```

data/examples/autometrics-sinatra-example/db.rb

@@ -0,0 +1,27 @@
+require 'autometrics'
+require 'yaml/store'
+
+module Database
+  # A simple database client that stores and retrieves data from a local YAML file.
+  class Client
+    include Autometrics
+
+    autometrics only: [:save_vote, :get_votes]
+
+    def initialize
+      @store = YAML::Store.new 'votes.yml'
+    end
+
+    def save_vote(vote)
+      @store.transaction do
+        @store['votes'] ||= {}
+        @store['votes'][vote] ||= 0
+        @store['votes'][vote] += 1
+      end
+    end
+
+    def get_votes
+      @store.transaction { @store['votes'] } || {}
+    end
+  end
+end

data/examples/autometrics-sinatra-example/suffragist.rb

@@ -0,0 +1,27 @@
+require 'sinatra'
+require 'prometheus/middleware/exporter'
+
+require_relative 'db'
+
+# NOTE - This creates a `/metrics` endpoint on the app that can be scraped by Prometheus
+use Prometheus::Middleware::Exporter
+
+# POST To vote for a pizza topping with query parameter `?vote=<topping>`
+post '/cast' do
+  @vote  = params['vote']
+  @db = Database::Client.new
+  @db.save_vote(@vote)
+
+  content_type :json
+  status 201
+  { vote: @vote }.to_json
+end
+
+# GET results of all votes, result should be a hash of strings to integers
+get '/results' do
+  @db = Database::Client.new
+  @votes = @db.get_votes
+
+  content_type :json
+  @votes.to_json
+end

data/lib/autometrics/logging.rb

@@ -0,0 +1,26 @@
+require 'logger'
+
+module Autometrics
+  module Logging
+    DEFAULT_LOG_LEVEL = Logger::WARN
+
+    LOG_LEVELS = {
+      'warn' => Logger::WARN,
+      'info' => Logger::INFO,
+      'debug' => Logger::DEBUG
+    }
+
+    @@logger = Logger.new(STDERR, level: ENV["LOG_LEVEL"] || DEFAULT_LOG_LEVEL)
+    @@logger.formatter = proc do |severity, datetime, progname, msg|
+      "[#{severity}] #{msg}\n"
+    end
+
+    # When you call module_function within a module, it creates copies of the specified methods as module-level methods.
+    module_function
+
+    # @return [Logger]
+    def logger
+      @@logger
+    end
+  end
+end

data/lib/autometrics/prometheus-client.rb

@@ -0,0 +1,37 @@
+require 'singleton'
+require 'prometheus/client'
+
+module Autometrics
+  AUTOMETRICS_PROMETHEUS_REGISTRY = Prometheus::Client.registry
+
+  class PrometheusClient
+    include Singleton
+
+    attr_accessor :function_calls_counter, :function_calls_duration
+
+    def initialize
+      @function_calls_counter = Prometheus::Client::Counter.new(
+        :function_calls_count,
+        docstring: 'A counter of function calls',
+        labels: [:function, :module, :result]
+      )
+      AUTOMETRICS_PROMETHEUS_REGISTRY.register(@function_calls_counter)
+
+      @function_calls_duration = Prometheus::Client::Histogram.new(
+        :function_calls_duration,
+        docstring: 'A histogram of function durations',
+        labels: [:function, :module]
+      )
+
+      AUTOMETRICS_PROMETHEUS_REGISTRY.register(function_calls_duration)
+    end
+
+    def test_get_values(labels)
+      # Example labels: { function: :bare_function, module: '' }
+      {
+        function_calls_counter: function_calls_counter.get(labels: { **labels, result: "ok" }),
+        function_calls_duration: function_calls_duration.get(labels: labels)
+      }
+    end
+  end
+end

data/lib/autometrics/version.rb

@@ -0,0 +1,3 @@
+  module Autometrics
+    VERSION = '0.0.1'
+  end

data/lib/autometrics.rb

@@ -0,0 +1,158 @@
+require 'prometheus/client'
+
+require_relative 'autometrics/prometheus-client'
+require_relative 'autometrics/logging'
+
+# Module for adding autometrics functionality to a class
+module Autometrics
+  PROMETHEUS = Autometrics::PrometheusClient.instance
+
+  # Add necessary autometrics methods and state when we're included in a class
+  def self.included(klass)
+    klass.extend(ClassMethods)
+    # HACK - turns off autometrics by default
+    klass.extend(Module.new do 
+      def initialize(*args, &block)
+        super
+        autometrics(disabled: true)
+      end
+    end)
+  end
+
+  # Module that automatically turns on autometrics when included
+  # INVESTIGATE - turn this into the pattern that allows you to pass arguments to the included method
+  module On
+    def self.included(klass)
+      klass.extend(ClassMethods)
+      # HACK - turns on autometrics here when user includes `On`
+      klass.extend(Module.new do 
+        def initialize(*args, &block)
+          super
+          autometrics(disabled: false)
+        end
+      end)
+    end
+  end
+
+  module ClassMethods
+    def autometrics(**options)
+      # Flag to turn off autometrics for this instance
+      @autometrics_enabled = !options[:disabled]
+
+      # Allow-list of methods (as symbols) for which we'll gather metrics
+      only = options[:only]
+      if only
+        @autometrics_only = if only.is_a?(Array) then only else [only] end
+      end
+
+      # Deny-list of methods (as symbols) to skip gathering autometrics for
+      @autometrics_skip = options[:skip] || []
+      # Do not gather metrics for the `initialize` method by default
+      @autometrics_skip_initialize = options[:skip_initialize] || true
+      # INVESTIGATE - add `skip_private_methods` option?
+      @autometrics_skip << :initialize if @autometrics_skip_initialize
+        
+      # TODO - log clearer warning if `disabled` is true and other options are passed in
+      should_warn_about_only = !@autometrics_enabled && instance_variable_defined?(@autometrics_only)
+      if should_warn_about_only
+        Logging.logger.warn "[Autometrics] 'only' option is present, but autometrics is disabled for this class, so no metrics will be gathered for #{@autometrics_only}"
+      end
+    end
+
+    # Metaprogramming magic to redefine methods as they are added to the class
+    def method_added(method_name)
+      return unless @autometrics_enabled
+
+      if instance_variable_defined?(:@autometrics_skip) && @autometrics_skip.include?(method_name)
+        Logging.logger.debug "Skipping autometrics for #{method_name} because you told me to skip it"
+        return
+      end
+
+      if instance_variable_defined?(:@autometrics_only) && !@autometrics_only.include?(method_name)
+        Logging.logger.debug "Skipping autometrics for #{method_name} because it's not in the list of 'only' methods"
+        return
+      end
+
+      # HACK - Temporarily disable this flag so that `define_method` does not go into an infinite loop when we redefine the method below
+      @autometrics_enabled = false
+
+      # Alias the original method so we can reference it later
+      original_method_name = "#{method_name}_without_autometrics".to_sym
+      alias_method original_method_name, method_name
+
+      # Redefine the original method and wrap it with autometrics logic
+      # NOTE - Only the contents inside define_method's block are executed in the context of the instance.
+      define_method(method_name) do |*args, &fn|
+        prometheus_client = Autometrics::PrometheusClient.instance
+        get_original_result = lambda { send(original_method_name, *args, &fn) }
+        module_name = self.class.name
+        wrap_with_autometrics(get_original_result, prometheus_client, module_name, method_name)
+      end
+
+      # HACK - Turn our autometrics flag back on, since we disabled it above
+      @autometrics_enabled = true
+    end
+  end
+end
+
+
+# NOTE - I think this is the only way to make autometrics work on top-level method calls
+#        That is, we need to to have a top-level export like this... but I'm not a Ruby expert, so I'm not sure
+#
+# Usage: `autometrics def my_method; end`
+def autometrics(method_name)
+  Autometrics::Logging.logger.debug "[self.autometrics] Adding autometrics to #{method_name}"
+
+  # Get a reference to the method that we're wrapping
+  original_method = method(method_name)
+
+  define_method(method_name) do |*args, &fn|
+    prometheus_client = Autometrics::PrometheusClient.instance
+    get_original_result = lambda { original_method.call(*args, &fn) }
+    # TODO - I'm not sure how to get/annotate the module name for a bare function call.
+    #        Right now we're just doing an empty string.
+    #        That said, in some code bases (like a Sinatra app?), we might consider the filename the module.
+    module_name = ""
+
+    wrap_with_autometrics(get_original_result, prometheus_client, module_name, method_name)
+  end
+end
+
+# Helper method for wrapping a method with autometrics logic
+# @param get_result_lambda - a lambda that returns the result of the original method
+# @param prometheus_client - an instance of the Prometheus client to record metrics
+# @param module_name - the name of the module that the method is defined in
+# @param method_name - the name of the method being wrapped
+def wrap_with_autometrics(get_result_lambda, prometheus_client, module_name, method_name)
+  labels = {
+    function: method_name,
+    module: module_name
+  }
+
+  begin
+    Autometrics::Logging.logger.debug "[self.wrap_with_autometrics::#{method_name}] Incrementing function calls with labels: #{labels}"
+
+    # Calculate execution time
+    # Use `Process.clock_gettime` instead of `Time.now` for measuring elapsed time
+    # See: https://blog.dnsimple.com/2018/03/elapsed-time-with-ruby-the-right-way/
+    start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    original_result = get_result_lambda.call
+    end_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    elapsed_time = end_time - start_time
+
+    Autometrics::Logging.logger.debug "[self.wrap_with_autometrics::#{method_name}] Observing method with labels: #{labels}"
+
+    prometheus_client.function_calls_duration.observe(elapsed_time, labels: labels)
+
+    # TODO - move to constants file
+    labels[:result] = "ok"
+    prometheus_client.function_calls_counter.increment(labels: labels)
+
+    original_result
+  rescue => error
+    # TODO - move to constants file
+    labels[:result] = "error"
+    prometheus_client.function_calls_counter.increment(labels: labels)
+    raise error
+  end
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: autometrics
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Brett Beutell
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-03-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+- !ruby/object:Gem::Dependency
+  name: prometheus-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Add developer-friendly observability to your Ruby code with minimal setup
+email:
+- brett@fiberplane.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- autometrics.gemspec
+- autometrics_test_quick.rb
+- examples/autometrics-sinatra-example/.gitignore
+- examples/autometrics-sinatra-example/Gemfile
+- examples/autometrics-sinatra-example/Gemfile.lock
+- examples/autometrics-sinatra-example/README.md
+- examples/autometrics-sinatra-example/db.rb
+- examples/autometrics-sinatra-example/suffragist.rb
+- lib/autometrics.rb
+- lib/autometrics/logging.rb
+- lib/autometrics/prometheus-client.rb
+- lib/autometrics/version.rb
+homepage: https://github.com/autometrics-dev/autometrics-ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.6
+signing_key:
+specification_version: 4
+summary: Ruby implmentation of autometrics library
+test_files: []