ddtelemetry 1.0.0a1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 410462bde4ad03647c35d4eb9706a513e8453e74d2218e9d60cc2f19b0a8f935
+  data.tar.gz: 8392f095624dc46eb70c463fdbf9e004fad56c273670eb54e650ae044140d101
+SHA512:
+  metadata.gz: 8fc60025054933c5f5b07a0d72bb3c457c67016324ce9670d6eee63b952f8ab5cdc0fd4cd85bdc92dc5e82b0f44eff69272137c7b1087b5aba9e6321afeca423
+  data.tar.gz: 34e45164626c7ec0b40382ac3c1fe4fd020a412c12b8903a93c34fac557210ef87045d69664de4a8198798d4be2d93433535ee3243da2613723efc28cf422663

data/.gitignore

@@ -0,0 +1,5 @@
+.DS_Store
+*.gem
+/.vscode/
+/coverage/
+/Gemfile.lock

data/.rspec

@@ -0,0 +1,3 @@
+-r ./spec/spec_helper.rb
+--format Fuubar
+--color

data/.rubocop.yml

@@ -0,0 +1,59 @@
+# ----- CONFIGURED -----
+
+AllCops:
+  TargetRubyVersion: 2.3
+  DisplayCopNames: true
+
+Style/TrailingCommaInArguments:
+  EnforcedStyleForMultiline: comma
+
+Style/TrailingCommaInLiteral:
+  EnforcedStyleForMultiline: comma
+
+Layout/IndentArray:
+  EnforcedStyle: consistent
+
+# Documentation lives elsewhere, and not everything needs to be documented.
+Style/Documentation:
+  Enabled: false
+
+# This doesn’t work well with RSpec.
+Lint/AmbiguousBlockAssociation:
+  Exclude:
+    - spec/**/*_spec.rb
+
+
+
+# ----- DISABLED (metrics) -----
+
+# Cops for metrics are disabled because they should not cause tests to fail.
+
+Metrics/AbcSize:
+  Enabled: false
+
+Metrics/BlockLength:
+  Enabled: false
+
+Metrics/BlockNesting:
+  Enabled: false
+
+Metrics/ClassLength:
+  Enabled: false
+
+Metrics/CyclomaticComplexity:
+  Enabled: false
+
+Metrics/LineLength:
+  Enabled: false
+
+Metrics/MethodLength:
+  Enabled: false
+
+Metrics/ModuleLength:
+  Enabled: false
+
+Metrics/ParameterLists:
+  Enabled: false
+
+Metrics/PerceivedComplexity:
+  Enabled: false

data/.travis.yml

@@ -0,0 +1,16 @@
+language: ruby
+
+rvm:
+  - "2.3"
+  - "2.4"
+
+branches:
+  only:
+    - "master"
+
+cache: bundler
+
+sudo: false
+
+git:
+  depth: 10

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at denis.defreyne@stoneship.org. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/Gemfile

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec
+
+group :devel do
+  gem 'codecov', require: false
+  gem 'fuubar'
+  gem 'rake'
+  gem 'rspec'
+  gem 'rspec-its'
+  gem 'rubocop', '~> 0.50'
+  gem 'timecop', '~> 0.9'
+end

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Denis Defreyne
+
+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/NEWS.md

@@ -0,0 +1,5 @@
+# DDTelemetry news
+
+## 1.0.0a1 (2017-12-02)
+
+Initial release.

data/README.md

@@ -0,0 +1,131 @@
+[![Gem version](https://img.shields.io/gem/v/ddtelemetry.svg)](http://rubygems.org/gems/ddtelemetry)
+[![Gem downloads](https://img.shields.io/gem/dt/ddtelemetry.svg)](http://rubygems.org/gems/ddtelemetry)
+[![Build status](https://img.shields.io/travis/ddfreyne/ddtelemetry.svg)](https://travis-ci.org/ddfreyne/ddtelemetry)
+[![Code Climate](https://img.shields.io/codeclimate/github/ddfreyne/ddtelemetry.svg)](https://codeclimate.com/github/ddfreyne/ddtelemetry)
+[![Code Coverage](https://img.shields.io/codecov/c/github/ddfreyne/ddtelemetry.svg)](https://codecov.io/gh/ddfreyne/ddtelemetry)
+
+# DDTelemetry
+
+_DDTelemetry_ provides in-process, non-timeseries telemetry for short-running Ruby processes.
+
+⚠️ This project is **experimental** and should not be used in production yet.
+
+If you are looking for a full-featured timeseries monitoring system, look no further than [Prometheus](https://prometheus.io/).
+
+## Example
+
+Take the following (naïve) cache implementation as a starting point:
+
+```ruby
+class Cache
+  def initialize
+    @map = {}
+  end
+
+  def []=(key, value)
+    @map[key] = value
+  end
+
+  def [](key)
+    @map[key]
+  end
+end
+```
+
+To start instrumenting this code, require `ddtelemetry`, pass a telemetry instance into the constructor, and record some metrics:
+
+```ruby
+require 'ddtelemetry'
+
+class Cache
+  def initialize(telemetry)
+    @telemetry = telemetry
+    @map = {}
+  end
+
+  def []=(key, value)
+    @telemetry.counter(:cache).increment(:set)
+
+    @map[key] = value
+  end
+
+  def [](key)
+    if @map.key?(key)
+      @telemetry.counter(:cache).increment([:get, :hit])
+    else
+      @telemetry.counter(:cache).increment([:get, :miss])
+    end
+
+    @map[key]
+  end
+end
+```
+
+Let’s construct a cache (with telemetry) and exercise it:
+
+```ruby
+telemetry = DDTelemetry::Registry.new
+cache = Cache.new(telemetry)
+
+cache['greeting']
+cache['greeting']
+cache['greeting'] = 'Hi there!'
+cache['greeting']
+cache['greeting']
+cache['greeting']
+```
+
+Finally, print the recorded telemetry values:
+
+```ruby
+p telemetry.counter(:cache).value(:set)
+# => 1
+
+p telemetry.counter(:cache).value([:get, :hit])
+# => 3
+
+p telemetry.counter(:cache).value([:get, :miss])
+# => 2
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'ddtelemetry'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ddtelemetry
+
+## Usage
+
+TODO
+
+## Development
+
+Install dependencies:
+
+    $ bundle
+
+Run tests:
+
+    $ bundle exec rake
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/ddfreyne/ddtelemetry. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the DDTelemetry project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/ddfreyne/ddtelemetry/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'rubocop/rake_task'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.verbose = false
+end
+
+RuboCop::RakeTask.new(:rubocop)
+
+task default: :test
+
+task test: %i[spec rubocop]

data/ddtelemetry.gemspec

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'lib/ddtelemetry/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'ddtelemetry'
+  spec.version       = DDTelemetry::VERSION
+  spec.authors       = ['Denis Defreyne']
+  spec.email         = ['denis+rubygems@denis.ws']
+
+  spec.summary       = 'Non-timeseries telemetry'
+  spec.homepage      = 'https://github.com/ddfreyne/ddtelemetry'
+  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/ddtelemetry/counter.rb

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

data/lib/ddtelemetry/labelled_counter.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module DDTelemetry
+  class LabelledCounter
+    def initialize
+      @counters = {}
+    end
+
+    def increment(label)
+      get(label).increment
+    end
+
+    def get(label)
+      @counters.fetch(label) { @counters[label] = Counter.new }
+    end
+
+    def empty?
+      @counters.empty?
+    end
+
+    def value(label)
+      get(label).value
+    end
+
+    def values
+      @counters.each_with_object({}) do |(label, counter), res|
+        res[label] = counter.value
+      end
+    end
+
+    def map
+      @counters.map { |(label, counter)| yield(label, counter) }
+    end
+  end
+end

data/lib/ddtelemetry/labelled_summary.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module DDTelemetry
+  class LabelledSummary
+    def initialize
+      @summaries = {}
+    end
+
+    def observe(value, label)
+      get(label).observe(value)
+    end
+
+    def get(label)
+      @summaries.fetch(label) { @summaries[label] = Summary.new }
+    end
+
+    def empty?
+      @summaries.empty?
+    end
+
+    def quantile(fraction, label)
+      get(label).quantile(fraction)
+    end
+
+    def map
+      @summaries.map { |(label, summary)| yield(label, summary) }
+    end
+
+    # TODO: add quantiles(fraction)
+    # TODO: add min(label)
+    # TODO: add mins
+    # TODO: add max(label)
+    # TODO: add maxs
+    # TODO: add sum(label)
+    # TODO: add sums
+  end
+end

data/lib/ddtelemetry/registry.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module DDTelemetry
+  class Registry
+    def initialize
+      @counters = {}
+      @summaries = {}
+    end
+
+    def counter(name)
+      @counters.fetch(name) { @counters[name] = LabelledCounter.new }
+    end
+
+    def summary(name)
+      @summaries.fetch(name) { @summaries[name] = LabelledSummary.new }
+    end
+  end
+end

data/lib/ddtelemetry/stopwatch.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module DDTelemetry
+  class Stopwatch
+    attr_reader :duration
+
+    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
+
+    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 running?
+      !@last_start.nil?
+    end
+
+    def stopped?
+      !running?
+    end
+  end
+end

data/lib/ddtelemetry/summary.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module DDTelemetry
+  class Summary
+    class EmptySummaryError < StandardError
+      def message
+        'Cannot calculate quantile for empty summary'
+      end
+    end
+
+    def initialize
+      @values = []
+    end
+
+    def observe(value)
+      @values << value
+      @sorted_values = nil
+    end
+
+    def count
+      @values.size
+    end
+
+    def sum
+      raise EmptySummaryError if @values.empty?
+      @values.reduce(:+)
+    end
+
+    def avg
+      sum / count
+    end
+
+    def min
+      quantile(0.0)
+    end
+
+    def max
+      quantile(1.0)
+    end
+
+    def quantile(fraction)
+      raise EmptySummaryError 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/ddtelemetry/table.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module DDTelemetry
+  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)
+        lines.concat(@rows.drop(1).map { |r| row_to_s(r, column_lengths) })
+      end.join("\n")
+    end
+
+    private
+
+    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/ddtelemetry/version.rb

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

data/lib/ddtelemetry.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative 'ddtelemetry/version'
+
+module DDTelemetry
+  def self.new
+    Registry.new
+  end
+end
+
+require_relative 'ddtelemetry/counter'
+require_relative 'ddtelemetry/summary'
+
+require_relative 'ddtelemetry/labelled_counter'
+require_relative 'ddtelemetry/labelled_summary'
+
+require_relative 'ddtelemetry/registry'
+require_relative 'ddtelemetry/stopwatch'
+
+require_relative 'ddtelemetry/table'

data/scripts/release

@@ -0,0 +1,97 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'octokit'
+
+def run(*args)
+  puts 'I will execute the following:'
+  puts '    ' + args.map { |a| a =~ /\s/ ? a.inspect : a }.join(' ')
+  print 'Is this correct? [y/N] '
+  res = gets
+  unless res.strip.casecmp('y').zero?
+    warn 'Answer was not Y; release aborted.'
+    exit 1
+  end
+
+  system('echo', *args)
+  system(*args)
+
+  print 'Continue? [y/N] '
+  res = gets
+  unless res.strip.casecmp('y').zero?
+    warn 'Answer was not Y; release aborted.'
+    exit 1
+  end
+
+  true
+end
+
+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 "  #{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 '=== Building new gem…'
+run('gem', 'build', 'ddtelemetry.gemspec')
+puts
+
+puts '=== Reading version…'
+require './lib/ddtelemetry/version'
+puts "Version = #{DDTelemetry::VERSION}"
+puts
+
+puts '=== Verifying that release does not yet exist…'
+releases = client.releases('ddfreyne/ddtelemetry')
+release = releases.find { |r| r.tag_name == DDTelemetry::VERSION }
+if release
+  warn 'Release already exists!'
+  warn 'ABORTED!'
+  exit 1
+end
+puts
+
+puts '=== Creating Git tag…'
+run('git', 'tag', '--sign', '--annotate', DDTelemetry::VERSION, '--message', "Version #{DDTelemetry::VERSION}")
+puts
+
+puts '=== Pushing Git data…'
+run('git', 'push', 'origin', '--tags')
+puts
+
+puts '=== Pushing gem…'
+run('gem', 'push', "ddtelemetry-#{DDTelemetry::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 = DDTelemetry::VERSION =~ /a|b|rc/ || DDTelemetry::VERSION =~ /^0/
+client.create_release(
+  'ddfreyne/ddtelemetry', DDTelemetry::VERSION,
+  prerelease: !is_prerelease.nil?,
+  body: release_notes
+)
+puts
+
+puts 'DONE!'

data/spec/ddtelemetry/counter_spec.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+describe DDTelemetry::Counter do
+  subject(:counter) { described_class.new }
+
+  it 'starts at 0' do
+    expect(counter.value).to eq(0)
+  end
+
+  describe '#increment' do
+    subject { counter.increment }
+
+    it 'increments' do
+      expect { subject }
+        .to change { counter.value }
+        .from(0)
+        .to(1)
+    end
+  end
+end

data/spec/ddtelemetry/labelled_counter_spec.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+describe DDTelemetry::LabelledCounter do
+  subject(:counter) { described_class.new }
+
+  describe 'new counter' do
+    it 'starts at 0' do
+      expect(subject.value(:erb)).to eq(0)
+      expect(subject.value(:haml)).to eq(0)
+    end
+
+    it 'has no values' do
+      expect(subject.values).to eq({})
+    end
+  end
+
+  describe '#increment' do
+    subject { counter.increment(:erb) }
+
+    it 'increments the matching value' do
+      expect { subject }
+        .to change { counter.value(:erb) }
+        .from(0)
+        .to(1)
+    end
+
+    it 'does not increment any other value' do
+      expect(counter.value(:haml)).to eq(0)
+      expect { subject }
+        .not_to change { counter.value(:haml) }
+    end
+
+    it 'correctly changes #values' do
+      expect { subject }
+        .to change { counter.values }
+        .from({})
+        .to(erb: 1)
+    end
+  end
+
+  describe '#get' do
+    subject { counter.get(:erb) }
+
+    context 'not incremented' do
+      its(:value) { is_expected.to eq(0) }
+    end
+
+    context 'incremented' do
+      before { counter.increment(:erb) }
+      its(:value) { is_expected.to eq(1) }
+    end
+
+    context 'other incremented' do
+      before { counter.increment(:haml) }
+      its(:value) { is_expected.to eq(0) }
+    end
+  end
+
+  describe '#empty?' do
+    subject { counter.empty? }
+
+    context 'not incremented' do
+      it { is_expected.to be }
+    end
+
+    context 'incremented' do
+      before { counter.increment(:erb) }
+      it { is_expected.not_to be }
+    end
+  end
+
+  describe '#map' do
+    subject { counter.map { |label, counter| [label, counter.value] } }
+
+    context 'not incremented' do
+      it { is_expected.to be_empty }
+    end
+
+    context 'incremented once' do
+      before { counter.increment(:erb) }
+      it { is_expected.to eq [[:erb, 1]] }
+    end
+
+    context 'both incremental multiple times' do
+      before do
+        counter.increment(:erb)
+        counter.increment(:erb)
+        counter.increment(:haml)
+      end
+
+      it { is_expected.to eq [[:erb, 2], [:haml, 1]] }
+    end
+  end
+end

data/spec/ddtelemetry/labelled_summary_spec.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+describe DDTelemetry::LabelledSummary do
+  subject(:summary) { described_class.new }
+
+  describe '#empty?' do
+    subject { summary.empty? }
+
+    context 'empty summary' do
+      it { is_expected.to be }
+    end
+
+    context 'some observations' do
+      before do
+        summary.observe(7.2, :erb)
+        summary.observe(5.3, :erb)
+        summary.observe(3.0, :haml)
+      end
+
+      it { is_expected.not_to be }
+    end
+  end
+
+  describe '#get' do
+    subject { summary.get(:erb) }
+
+    context 'empty summary' do
+      its(:count) { is_expected.to eq(0) }
+    end
+
+    context 'one observation with that label' do
+      before { summary.observe(0.1, :erb) }
+      its(:count) { is_expected.to eq(1) }
+    end
+
+    context 'one observation with a different label' do
+      before { summary.observe(0.1, :haml) }
+      its(:count) { is_expected.to eq(0) }
+    end
+  end
+
+  describe '#map' do
+    before do
+      subject.observe(2.1, :erb)
+      subject.observe(4.1, :erb)
+      subject.observe(5.3, :haml)
+    end
+
+    it 'yields label and summary' do
+      res = subject.map { |label, summary| [label, summary.avg.round(3)] }
+      expect(res).to eql([[:erb, 3.1], [:haml, 5.3]])
+    end
+  end
+
+  describe '#quantile' do
+    before do
+      subject.observe(2.1, :erb)
+      subject.observe(4.1, :erb)
+      subject.observe(5.3, :haml)
+    end
+
+    it 'has proper quantiles for :erb' do
+      expect(subject.quantile(0.00, :erb)).to be_within(0.000001).of(2.1)
+      expect(subject.quantile(0.25, :erb)).to be_within(0.000001).of(2.6)
+      expect(subject.quantile(0.50, :erb)).to be_within(0.000001).of(3.1)
+      expect(subject.quantile(0.90, :erb)).to be_within(0.000001).of(3.9)
+      expect(subject.quantile(0.99, :erb)).to be_within(0.000001).of(4.08)
+    end
+
+    it 'has proper quantiles for :erb' do
+      expect(subject.quantile(0.00, :haml)).to be_within(0.000001).of(5.3)
+      expect(subject.quantile(0.25, :haml)).to be_within(0.000001).of(5.3)
+      expect(subject.quantile(0.50, :haml)).to be_within(0.000001).of(5.3)
+      expect(subject.quantile(0.90, :haml)).to be_within(0.000001).of(5.3)
+      expect(subject.quantile(0.99, :haml)).to be_within(0.000001).of(5.3)
+    end
+  end
+end

data/spec/ddtelemetry/stopwatch_spec.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+describe DDTelemetry::Stopwatch do
+  subject(:stopwatch) { described_class.new }
+
+  after { Timecop.return }
+
+  it 'is zero by default' do
+    expect(stopwatch.duration).to eq(0.0)
+  end
+
+  # TODO: if running, raise error when asking for #duration
+
+  it 'records correct duration after start+stop' do
+    Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 0))
+    stopwatch.start
+
+    Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 1))
+    stopwatch.stop
+
+    expect(stopwatch.duration).to eq(1.0)
+  end
+
+  it 'records correct duration after start+stop+start+stop' do
+    Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 0))
+    stopwatch.start
+
+    Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 1))
+    stopwatch.stop
+
+    Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 3))
+    stopwatch.start
+
+    Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 6))
+    stopwatch.stop
+
+    expect(stopwatch.duration).to eq(1.0 + 3.0)
+  end
+
+  it 'errors when stopping when not started' do
+    expect { stopwatch.stop }.to raise_error(DDTelemetry::Stopwatch::NotRunningError)
+  end
+
+  it 'errors when starting when already started' do
+    stopwatch.start
+    expect { stopwatch.start }.to raise_error(DDTelemetry::Stopwatch::AlreadyRunningError)
+  end
+
+  it 'reports running status' do
+    expect(stopwatch).not_to be_running
+    expect(stopwatch).to be_stopped
+
+    stopwatch.start
+
+    expect(stopwatch).to be_running
+    expect(stopwatch).not_to be_stopped
+
+    stopwatch.stop
+
+    expect(stopwatch).not_to be_running
+    expect(stopwatch).to be_stopped
+  end
+end

data/spec/ddtelemetry/summary_spec.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+describe DDTelemetry::Summary do
+  subject(:summary) { described_class.new }
+
+  context 'no observations' do
+    it 'errors on #min' do
+      expect { subject.min }
+        .to raise_error(DDTelemetry::Summary::EmptySummaryError)
+    end
+
+    it 'errors on #max' do
+      expect { subject.max }
+        .to raise_error(DDTelemetry::Summary::EmptySummaryError)
+    end
+
+    it 'errors on #avg' do
+      expect { subject.avg }
+        .to raise_error(DDTelemetry::Summary::EmptySummaryError)
+    end
+
+    it 'errors on #sum' do
+      expect { subject.sum }
+        .to raise_error(DDTelemetry::Summary::EmptySummaryError)
+    end
+
+    its(:count) { is_expected.to eq(0) }
+  end
+
+  context 'one observation' do
+    before { subject.observe(2.1) }
+
+    its(:count) { is_expected.to eq(1) }
+    its(:sum) { is_expected.to eq(2.1) }
+    its(:avg) { is_expected.to eq(2.1) }
+    its(:min) { is_expected.to eq(2.1) }
+    its(:max) { is_expected.to eq(2.1) }
+
+    it 'has proper quantiles' do
+      expect(subject.quantile(0.00)).to eq(2.1)
+      expect(subject.quantile(0.25)).to eq(2.1)
+      expect(subject.quantile(0.50)).to eq(2.1)
+      expect(subject.quantile(0.90)).to eq(2.1)
+      expect(subject.quantile(0.99)).to eq(2.1)
+    end
+  end
+
+  context 'two observations' do
+    before do
+      subject.observe(2.1)
+      subject.observe(4.1)
+    end
+
+    its(:count) { is_expected.to be_within(0.000001).of(2) }
+    its(:sum) { is_expected.to be_within(0.000001).of(6.2) }
+    its(:avg) { is_expected.to be_within(0.000001).of(3.1) }
+    its(:min) { is_expected.to be_within(0.000001).of(2.1) }
+    its(:max) { is_expected.to be_within(0.000001).of(4.1) }
+
+    it 'has proper quantiles' do
+      expect(subject.quantile(0.00)).to be_within(0.000001).of(2.1)
+      expect(subject.quantile(0.25)).to be_within(0.000001).of(2.6)
+      expect(subject.quantile(0.50)).to be_within(0.000001).of(3.1)
+      expect(subject.quantile(0.90)).to be_within(0.000001).of(3.9)
+      expect(subject.quantile(0.99)).to be_within(0.000001).of(4.08)
+    end
+  end
+end

data/spec/ddtelemetry/table_spec.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+describe DDTelemetry::Table do
+  let(:table) { described_class.new(rows) }
+
+  let(:rows) do
+    [
+      %w[name awesomeness],
+      %w[denis high],
+      %w[REDACTED low],
+    ]
+  end
+
+  example do
+    expect(table.to_s).to eq(<<~TABLE.rstrip)
+          name │ awesomeness
+      ─────────┼────────────
+         denis │        high
+      REDACTED │         low
+    TABLE
+  end
+end

data/spec/ddtelemetry_spec.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+describe DDTelemetry do
+  it 'has a version number' do
+    expect(DDTelemetry::VERSION).not_to be nil
+  end
+
+  subject { described_class.new }
+
+  example do
+    expect(subject.counter(:filters).values).to eq({})
+    expect(subject.counter(:filters).get(:erb).value).to eq(0)
+    expect(subject.counter(:filters).value(:erb)).to eq(0)
+
+    subject.counter(:filters).increment(:erb)
+    expect(subject.counter(:filters).values).to eq(erb: 1)
+    expect(subject.counter(:filters).get(:erb).value).to eq(1)
+    expect(subject.counter(:filters).value(:erb)).to eq(1)
+  end
+
+  example do
+    subject.summary(:filters).observe(0.1, :erb)
+    expect(subject.summary(:filters).quantile(0.0, :erb)).to be_within(0.00001).of(0.1)
+    expect(subject.summary(:filters).quantile(0.5, :erb)).to be_within(0.00001).of(0.1)
+    expect(subject.summary(:filters).quantile(1.0, :erb)).to be_within(0.00001).of(0.1)
+
+    subject.summary(:filters).observe(1.1, :erb)
+    expect(subject.summary(:filters).quantile(0.0, :erb)).to be_within(0.00001).of(0.1)
+    expect(subject.summary(:filters).quantile(0.5, :erb)).to be_within(0.00001).of(0.6)
+    expect(subject.summary(:filters).quantile(1.0, :erb)).to be_within(0.00001).of(1.1)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'simplecov'
+SimpleCov.start
+
+require 'codecov'
+SimpleCov.formatter = SimpleCov::Formatter::Codecov
+
+require 'ddtelemetry'
+
+require 'fuubar'
+require 'rspec/its'
+require 'timecop'
+
+RSpec.configure do |c|
+  c.fuubar_progress_bar_options = {
+    format: '%c/%C |<%b>%i| %p%%',
+  }
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: ddtelemetry
+version: !ruby/object:Gem::Version
+  version: 1.0.0a1
+platform: ruby
+authors:
+- Denis Defreyne
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-12-02 00:00:00.000000000 Z
+dependencies: []
+description: 
+email:
+- denis+rubygems@denis.ws
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- NEWS.md
+- README.md
+- Rakefile
+- ddtelemetry.gemspec
+- lib/ddtelemetry.rb
+- lib/ddtelemetry/counter.rb
+- lib/ddtelemetry/labelled_counter.rb
+- lib/ddtelemetry/labelled_summary.rb
+- lib/ddtelemetry/registry.rb
+- lib/ddtelemetry/stopwatch.rb
+- lib/ddtelemetry/summary.rb
+- lib/ddtelemetry/table.rb
+- lib/ddtelemetry/version.rb
+- scripts/release
+- spec/ddtelemetry/counter_spec.rb
+- spec/ddtelemetry/labelled_counter_spec.rb
+- spec/ddtelemetry/labelled_summary_spec.rb
+- spec/ddtelemetry/stopwatch_spec.rb
+- spec/ddtelemetry/summary_spec.rb
+- spec/ddtelemetry/table_spec.rb
+- spec/ddtelemetry_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/ddfreyne/ddtelemetry
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.3
+signing_key: 
+specification_version: 4
+summary: Non-timeseries telemetry
+test_files: []