ddmetrics 1.0.0rc1

data/Rakefile

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'rubocop/rake_task'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.verbose = false
+end
+
+task :test_samples do
+  sh 'bundle exec ruby samples/cache.rb > /dev/null'
+end
+
+RuboCop::RakeTask.new(:rubocop)
+
+task default: :test
+
+task test: %i[spec rubocop test_samples]

data/ddmetrics.gemspec

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'lib/ddmetrics/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'ddmetrics'
+  spec.version       = DDMetrics::VERSION
+  spec.authors       = ['Denis Defreyne']
+  spec.email         = ['denis+rubygems@denis.ws']
+
+  spec.summary       = 'Non-timeseries measurements for Ruby programs'
+  spec.homepage      = 'https://github.com/ddfreyne/ddmetrics'
+  spec.license       = 'MIT'
+
+  spec.required_ruby_version = '>= 2.3.0'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.require_paths = ['lib']
+end

data/lib/ddmetrics.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'ddmetrics/version'
+
+module DDMetrics
+end
+
+require_relative 'ddmetrics/basic_counter'
+require_relative 'ddmetrics/basic_summary'
+
+require_relative 'ddmetrics/metric'
+require_relative 'ddmetrics/counter'
+require_relative 'ddmetrics/summary'
+
+require_relative 'ddmetrics/stopwatch'
+
+require_relative 'ddmetrics/table'
+require_relative 'ddmetrics/printer'
+require_relative 'ddmetrics/stats'

data/lib/ddmetrics/basic_counter.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module DDMetrics
+  class BasicCounter
+    attr_reader :value
+
+    def initialize
+      @value = 0
+    end
+
+    def increment
+      @value += 1
+    end
+  end
+end

data/lib/ddmetrics/basic_summary.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module DDMetrics
+  class BasicSummary
+    attr_reader :values
+
+    def initialize
+      @values = []
+    end
+
+    def observe(value)
+      @values << value
+    end
+  end
+end

data/lib/ddmetrics/counter.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module DDMetrics
+  class Counter < Metric
+    def increment(label)
+      validate_label(label)
+      basic_metric_for(label, BasicCounter).increment
+    end
+
+    def get(label)
+      validate_label(label)
+      basic_metric_for(label, BasicCounter).value
+    end
+
+    def to_s
+      DDMetrics::Printer.new.counter_to_s(self)
+    end
+  end
+end

data/lib/ddmetrics/metric.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module DDMetrics
+  class Metric
+    include Enumerable
+
+    def initialize
+      @basic_metrics = {}
+    end
+
+    def get(label)
+      basic_metric_for(label, BasicCounter)
+    end
+
+    def labels
+      @basic_metrics.keys
+    end
+
+    def each
+      @basic_metrics.each_key do |label|
+        yield(label, get(label))
+      end
+    end
+
+    # @api private
+    def basic_metric_for(label, basic_class)
+      @basic_metrics.fetch(label) { @basic_metrics[label] = basic_class.new }
+    end
+
+    # @api private
+    def validate_label(label)
+      return if label.is_a?(Hash)
+      raise ArgumentError, 'label argument must be a hash'
+    end
+  end
+end

data/lib/ddmetrics/printer.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module DDMetrics
+  class Printer
+    def summary_to_s(summary)
+      DDMetrics::Table.new(table_for_summary(summary)).to_s
+    end
+
+    def counter_to_s(counter)
+      DDMetrics::Table.new(table_for_counter(counter)).to_s
+    end
+
+    private
+
+    def label_to_s(label)
+      label.to_a.sort.map { |pair| pair.join('=') }.join(' ')
+    end
+
+    def table_for_summary(summary)
+      headers = ['', 'count', 'min', '.50', '.90', '.95', 'max', 'tot']
+
+      rows = summary.labels.map do |label|
+        stats = summary.get(label)
+
+        count = stats.count
+        min   = stats.min
+        p50   = stats.quantile(0.50)
+        p90   = stats.quantile(0.90)
+        p95   = stats.quantile(0.95)
+        tot   = stats.sum
+        max   = stats.max
+
+        [label_to_s(label), count.to_s] + [min, p50, p90, p95, max, tot].map { |r| format('%4.2f', r) }
+      end
+
+      [headers] + rows
+    end
+
+    def table_for_counter(counter)
+      headers = ['', 'count']
+
+      rows = counter.labels.map do |label|
+        [label_to_s(label), counter.get(label).to_s]
+      end
+
+      [headers] + rows
+    end
+  end
+end

data/lib/ddmetrics/stats.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module DDMetrics
+  class Stats
+    class EmptyError < StandardError
+      def message
+        'Not enough data to perform calculation'
+      end
+    end
+
+    def initialize(values)
+      @values = values
+    end
+
+    def inspect
+      "<#{self.class} count=#{count}>"
+    end
+
+    def count
+      @values.size
+    end
+
+    def sum
+      raise EmptyError if @values.empty?
+      @values.reduce(:+)
+    end
+
+    def avg
+      sum.to_f / count
+    end
+
+    def min
+      quantile(0.0)
+    end
+
+    def max
+      quantile(1.0)
+    end
+
+    def quantile(fraction)
+      raise EmptyError if @values.empty?
+
+      target = (@values.size - 1) * fraction.to_f
+      interp = target % 1.0
+      sorted_values[target.floor] * (1.0 - interp) + sorted_values[target.ceil] * interp
+    end
+
+    private
+
+    def sorted_values
+      @sorted_values ||= @values.sort
+    end
+  end
+end

data/lib/ddmetrics/stopwatch.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module DDMetrics
+  class Stopwatch
+    class AlreadyRunningError < StandardError
+      def message
+        'Cannot start, because stopwatch is already running'
+      end
+    end
+
+    class NotRunningError < StandardError
+      def message
+        'Cannot stop, because stopwatch is not running'
+      end
+    end
+
+    class StillRunningError < StandardError
+      def message
+        'Cannot get duration, because stopwatch is still running'
+      end
+    end
+
+    def initialize
+      @duration = 0.0
+      @last_start = nil
+    end
+
+    def start
+      raise AlreadyRunningError if running?
+      @last_start = Time.now
+    end
+
+    def stop
+      raise NotRunningError unless running?
+      @duration += (Time.now - @last_start)
+      @last_start = nil
+    end
+
+    def duration
+      raise StillRunningError if running?
+      @duration
+    end
+
+    def running?
+      !@last_start.nil?
+    end
+
+    def stopped?
+      !running?
+    end
+  end
+end

data/lib/ddmetrics/summary.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module DDMetrics
+  class Summary < Metric
+    def observe(value, label)
+      validate_label(label)
+      basic_metric_for(label, BasicSummary).observe(value)
+    end
+
+    def get(label)
+      validate_label(label)
+      values = basic_metric_for(label, BasicSummary).values
+      DDMetrics::Stats.new(values)
+    end
+
+    def to_s
+      DDMetrics::Printer.new.summary_to_s(self)
+    end
+  end
+end

data/lib/ddmetrics/table.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module DDMetrics
+  class Table
+    def initialize(rows)
+      @rows = rows
+    end
+
+    def to_s
+      columns = @rows.transpose
+      column_lengths = columns.map { |c| c.map(&:size).max }
+
+      [].tap do |lines|
+        lines << row_to_s(@rows[0], column_lengths)
+        lines << separator(column_lengths)
+        rows = sort_rows(@rows.drop(1))
+        lines.concat(rows.map { |r| row_to_s(r, column_lengths) })
+      end.join("\n")
+    end
+
+    private
+
+    def sort_rows(rows)
+      rows.sort_by { |r| r.first.downcase }
+    end
+
+    def row_to_s(row, column_lengths)
+      values = row.zip(column_lengths).map { |text, length| text.rjust(length) }
+      values[0] + ' │ ' + values[1..-1].join('   ')
+    end
+
+    def separator(column_lengths)
+      (+'').tap do |s|
+        s << '─' * column_lengths[0]
+        s << '─┼─'
+        s << column_lengths[1..-1].map { |l| '─' * l }.join('───')
+      end
+    end
+  end
+end

data/lib/ddmetrics/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module DDMetrics
+  VERSION = '1.0.0rc1'
+end

data/samples/cache.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'ddmetrics'
+
+class Cache
+  attr_reader :counter
+
+  def initialize
+    @map = {}
+    @counter = DDMetrics::Counter.new
+  end
+
+  def []=(key, value)
+    @counter.increment(type: :set)
+
+    @map[key] = value
+  end
+
+  def [](key)
+    if @map.key?(key)
+      @counter.increment(type: :get_hit)
+    else
+      @counter.increment(type: :get_miss)
+    end
+
+    @map[key]
+  end
+end
+
+cache = Cache.new
+
+cache['greeting']
+cache['greeting']
+cache['greeting'] = 'Hi there!'
+cache['greeting']
+cache['greeting']
+cache['greeting']
+
+p cache.counter.get(type: :set)
+# => 1
+
+p cache.counter.get(type: :get_hit)
+# => 3
+
+p cache.counter.get(type: :get_miss)
+# => 2
+
+puts cache.counter

data/scripts/release

@@ -0,0 +1,115 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'json'
+require 'netrc'
+require 'octokit'
+require 'shellwords'
+require 'uri'
+
+def run(*args)
+  puts('<exec> ' + args.map { |s| Shellwords.escape(s) }.join(' '))
+  system(*args)
+end
+
+gem_name = 'ddmetrics'
+version_constant = 'DDMetrics::VERSION'
+gem_path = 'ddmetrics'
+
+puts '=== Logging in to GitHub’s API…'
+client = Octokit::Client.new(netrc: true)
+puts
+
+puts '=== Deleting old *.gem files…'
+Dir['*.gem'].each do |fn|
+  puts "deleting #{fn}…"
+  FileUtils.rm_f(fn)
+end
+puts
+
+puts '=== Verifying presence of release date…'
+unless File.readlines('NEWS.md').drop(2).first =~ / \(\d{4}-\d{2}-\d{2}\)$/
+  warn 'No proper release date found!'
+  exit 1
+end
+puts
+
+puts '=== Reading version…'
+require "./lib/#{gem_path}/version"
+version = eval(version_constant) # rubocop:disable Security/Eval
+puts "Version = #{version}"
+puts
+
+puts '=== Building new gem…'
+run('gem', 'build', 'ddmetrics.gemspec')
+puts
+
+puts '=== Verifying that gems were built properly…'
+gem_filename = "#{gem_name}-#{version}.gem"
+unless File.file?(gem_filename)
+  warn "Error: Could not find gem: #{gem_filename}"
+  exit 1
+end
+puts
+
+puts '=== Verifying that gem version does not yet exist…'
+url = URI.parse("https://rubygems.org/api/v1/versions/#{gem_name}.json")
+response = Net::HTTP.get_response(url)
+existing_versions =
+  case response.code
+  when '404'
+    []
+  when '200'
+    JSON.parse(response.body).map { |e| e.fetch('number') }
+  else
+    warn "Error: Couldn’t fetch version information for #{gem_name} (status #{response.code})"
+    exit 1
+  end
+if existing_versions.include?(version)
+  warn "Error: #{gem_name} v#{version} already exists"
+  exit 1
+end
+puts
+
+puts '=== Verifying that release does not yet exist…'
+releases = client.releases('ddfreyne/ddmetrics')
+release = releases.find { |r| r.tag_name == DDMetrics::VERSION }
+if release
+  warn 'Release already exists!'
+  warn 'ABORTED!'
+  exit 1
+end
+puts
+
+puts '=== Creating Git tag…'
+run('git', 'tag', '--sign', '--annotate', DDMetrics::VERSION, '--message', "Version #{DDMetrics::VERSION}")
+puts
+
+puts '=== Pushing Git data…'
+run('git', 'push', 'origin', '--tags')
+puts
+
+puts '=== Pushing gem…'
+run('gem', 'push', "ddmetrics-#{DDMetrics::VERSION}.gem")
+puts
+
+puts '=== Reading release notes…'
+release_notes =
+  File.readlines('NEWS.md')
+      .drop(4)
+      .take_while { |l| l !~ /^## / }
+      .join
+puts
+
+puts '=== Creating release on GitHub…'
+sleep 3 # Give GitHub some time to detect the new tag
+is_prerelease = DDMetrics::VERSION =~ /a|b|rc/ || DDMetrics::VERSION =~ /^0/
+client.create_release(
+  'ddfreyne/ddmetrics', DDMetrics::VERSION,
+  prerelease: !is_prerelease.nil?,
+  body: release_notes
+)
+puts
+
+puts 'DONE!'