ddtelemetry 1.0.0a1 → 1.0.0a2

data/spec/ddtelemetry/summary_spec.rb

@@ -3,66 +3,72 @@
 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)
+  describe '#get' do
+    subject { summary.get(:erb) }
+
+    before do
+      summary.observe(2.1, :erb)
+      summary.observe(4.1, :erb)
+      summary.observe(5.3, :haml)
     end
 
-    it 'errors on #max' do
-      expect { subject.max }
-        .to raise_error(DDTelemetry::Summary::EmptySummaryError)
+    it { is_expected.to be_a(DDTelemetry::Stats) }
+
+    its(:sum) { is_expected.to eq(2.1 + 4.1) }
+    its(:count) { is_expected.to eq(2) }
+  end
+
+  describe '#labels' do
+    subject { summary.labels }
+
+    before do
+      summary.observe(2.1, :erb)
+      summary.observe(4.1, :erb)
+      summary.observe(5.3, :haml)
     end
 
-    it 'errors on #avg' do
-      expect { subject.avg }
-        .to raise_error(DDTelemetry::Summary::EmptySummaryError)
+    it { is_expected.to contain_exactly(:haml, :erb) }
+  end
+
+  describe '#each' do
+    subject do
+      {}.tap do |res|
+        summary.each { |label, stats| res[label] = stats.avg.round(2) }
+      end
     end
 
-    it 'errors on #sum' do
-      expect { subject.sum }
-        .to raise_error(DDTelemetry::Summary::EmptySummaryError)
+    before do
+      summary.observe(2.1, :erb)
+      summary.observe(4.1, :erb)
+      summary.observe(5.3, :haml)
     end
 
-    its(:count) { is_expected.to eq(0) }
-  end
+    it { is_expected.to eq(haml: 5.3, erb: 3.1) }
 
-  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)
+    it 'is enumerable' do
+      expect(summary.map { |_label, stats| stats.sum }.sort)
+        .to eq([5.3, 2.1 + 4.1])
     end
   end
 
-  context 'two observations' do
+  describe '#to_s' do
+    subject { summary.to_s }
+
     before do
-      subject.observe(2.1)
-      subject.observe(4.1)
+      summary.observe(2.1, :erb)
+      summary.observe(4.1, :erb)
+      summary.observe(5.3, :haml)
     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)
+    it 'returns table' do
+      expected = <<~TABLE
+             │ count    min    .50    .90    .95    max    tot
+        ─────┼────────────────────────────────────────────────
+         erb │     2   2.10   3.10   3.90   4.00   4.10   6.20
+        haml │     1   5.30   5.30   5.30   5.30   5.30   5.30
+      TABLE
+
+      expect(subject.strip).to eq(expected.strip)
     end
   end
 end

data/spec/ddtelemetry_spec.rb

@@ -4,29 +4,4 @@ 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

@@ -14,6 +14,6 @@ require 'timecop'
 
 RSpec.configure do |c|
   c.fuubar_progress_bar_options = {
-    format: '%c/%C |<%b>%i| %p%%',
+    format: '%c/%C |<%b>%i| %p%%', # rubocop:disable Style/FormatStringToken
   }
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ddtelemetry
 version: !ruby/object:Gem::Version
-  version: 1.0.0a1
+  version: 1.0.0a2
 platform: ruby
 authors:
 - Denis Defreyne
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-12-02 00:00:00.000000000 Z
+date: 2017-12-18 00:00:00.000000000 Z
 dependencies: []
 description: 
 email:
@@ -29,18 +29,23 @@ files:
 - Rakefile
 - ddtelemetry.gemspec
 - lib/ddtelemetry.rb
+- lib/ddtelemetry/basic_counter.rb
+- lib/ddtelemetry/basic_summary.rb
 - lib/ddtelemetry/counter.rb
-- lib/ddtelemetry/labelled_counter.rb
-- lib/ddtelemetry/labelled_summary.rb
-- lib/ddtelemetry/registry.rb
+- lib/ddtelemetry/metric.rb
+- lib/ddtelemetry/printer.rb
+- lib/ddtelemetry/stats.rb
 - lib/ddtelemetry/stopwatch.rb
 - lib/ddtelemetry/summary.rb
 - lib/ddtelemetry/table.rb
 - lib/ddtelemetry/version.rb
+- roadmap.md
+- samples/cache.rb
 - scripts/release
+- spec/ddtelemetry/basic_counter_spec.rb
+- spec/ddtelemetry/basic_summary_spec.rb
 - spec/ddtelemetry/counter_spec.rb
-- spec/ddtelemetry/labelled_counter_spec.rb
-- spec/ddtelemetry/labelled_summary_spec.rb
+- spec/ddtelemetry/stats_spec.rb
 - spec/ddtelemetry/stopwatch_spec.rb
 - spec/ddtelemetry/summary_spec.rb
 - spec/ddtelemetry/table_spec.rb

data/lib/ddtelemetry/labelled_counter.rb

@@ -1,35 +0,0 @@
-# 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

@@ -1,37 +0,0 @@
-# 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

@@ -1,18 +0,0 @@
-# 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/spec/ddtelemetry/labelled_counter_spec.rb

@@ -1,94 +0,0 @@
-# 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

@@ -1,78 +0,0 @@
-# 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