ddmetrics 1.0.0rc1

data/spec/ddmetrics/basic_counter_spec.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+describe DDMetrics::BasicCounter 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/ddmetrics/basic_summary_spec.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+describe DDMetrics::BasicSummary do
+  subject(:summary) { described_class.new }
+
+  context 'no observations' do
+    its(:values) { is_expected.to be_empty }
+  end
+
+  context 'one observation' do
+    before { subject.observe(2.1) }
+    its(:values) { is_expected.to eq([2.1]) }
+  end
+
+  context 'two observations' do
+    before do
+      subject.observe(2.1)
+      subject.observe(4.1)
+    end
+
+    its(:values) { is_expected.to eq([2.1, 4.1]) }
+  end
+end

data/spec/ddmetrics/counter_spec.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+describe DDMetrics::Counter do
+  subject(:counter) { described_class.new }
+
+  describe 'new counter' do
+    it 'starts at 0' do
+      expect(subject.get(filter: :erb)).to eq(0)
+      expect(subject.get(filter: :haml)).to eq(0)
+    end
+  end
+
+  describe '#increment' do
+    subject { counter.increment(filter: :erb) }
+
+    it 'increments the matching value' do
+      expect { subject }
+        .to change { counter.get(filter: :erb) }
+        .from(0)
+        .to(1)
+    end
+
+    it 'does not increment any other value' do
+      expect(counter.get(filter: :haml)).to eq(0)
+      expect { subject }
+        .not_to change { counter.get(filter: :haml) }
+    end
+
+    context 'non-hash label' do
+      subject { counter.increment('WRONG UGH') }
+
+      it 'errors' do
+        expect { subject }.to raise_error(ArgumentError, 'label argument must be a hash')
+      end
+    end
+  end
+
+  describe '#get' do
+    subject { counter.get(filter: :erb) }
+
+    context 'not incremented' do
+      it { is_expected.to eq(0) }
+    end
+
+    context 'incremented' do
+      before { counter.increment(filter: :erb) }
+      it { is_expected.to eq(1) }
+    end
+
+    context 'other incremented' do
+      before { counter.increment(filter: :haml) }
+      it { is_expected.to eq(0) }
+    end
+  end
+
+  describe '#labels' do
+    subject { counter.labels }
+
+    before do
+      counter.increment(filter: :erb)
+      counter.increment(filter: :erb)
+      counter.increment(filter: :haml)
+    end
+
+    it { is_expected.to match_array([{ filter: :haml }, { filter: :erb }]) }
+  end
+
+  describe '#each' do
+    subject do
+      {}.tap do |res|
+        counter.each { |label, count| res[label] = count }
+      end
+    end
+
+    before do
+      counter.increment(filter: :erb)
+      counter.increment(filter: :erb)
+      counter.increment(filter: :haml)
+    end
+
+    it { is_expected.to eq({ filter: :haml } => 1, { filter: :erb } => 2) }
+
+    it 'is enumerable' do
+      expect(counter.map { |_label, count| count }.sort)
+        .to eq([1, 2])
+    end
+  end
+
+  describe '#to_s' do
+    subject { counter.to_s }
+
+    before do
+      counter.increment(filter: :erb)
+      counter.increment(filter: :erb)
+      counter.increment(filter: :haml)
+    end
+
+    it 'returns table' do
+      expected = <<~TABLE
+                    │ count
+        ────────────┼──────
+         filter=erb │     2
+        filter=haml │     1
+      TABLE
+
+      expect(subject.strip).to eq(expected.strip)
+    end
+  end
+end

data/spec/ddmetrics/stats_spec.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+describe DDMetrics::Stats do
+  subject(:stats) { described_class.new(values) }
+
+  context 'no values' do
+    let(:values) { [] }
+
+    it 'errors on #min' do
+      expect { subject.min }
+        .to raise_error(DDMetrics::Stats::EmptyError)
+    end
+
+    it 'errors on #max' do
+      expect { subject.max }
+        .to raise_error(DDMetrics::Stats::EmptyError)
+    end
+
+    it 'errors on #avg' do
+      expect { subject.avg }
+        .to raise_error(DDMetrics::Stats::EmptyError)
+    end
+
+    it 'errors on #sum' do
+      expect { subject.sum }
+        .to raise_error(DDMetrics::Stats::EmptyError)
+    end
+
+    its(:count) { is_expected.to eq(0) }
+  end
+
+  context 'one value' do
+    let(:values) { [2.1] }
+
+    its(:inspect) { is_expected.to eq('<DDMetrics::Stats count=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 values' do
+    let(:values) { [2.1, 4.1] }
+
+    its(:inspect) { is_expected.to eq('<DDMetrics::Stats count=2>') }
+    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
+
+  context 'integer values' do
+    let(:values) { [1, 2] }
+
+    its(:count) { is_expected.to be_within(0.000001).of(2) }
+    its(:sum) { is_expected.to be_within(0.000001).of(3) }
+    its(:avg) { is_expected.to be_within(0.000001).of(1.5) }
+    its(:min) { is_expected.to be_within(0.000001).of(1) }
+    its(:max) { is_expected.to be_within(0.000001).of(2) }
+
+    it 'has proper quantiles' do
+      expect(subject.quantile(0.00)).to be_within(0.000001).of(1.0)
+      expect(subject.quantile(0.25)).to be_within(0.000001).of(1.25)
+      expect(subject.quantile(0.50)).to be_within(0.000001).of(1.5)
+      expect(subject.quantile(0.90)).to be_within(0.000001).of(1.9)
+      expect(subject.quantile(0.99)).to be_within(0.000001).of(1.99)
+    end
+  end
+end

data/spec/ddmetrics/stopwatch_spec.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+describe DDMetrics::Stopwatch do
+  subject(:stopwatch) { described_class.new }
+
+  after { Timecop.return }
+
+  it 'is zero by default' do
+    expect(stopwatch.duration).to eq(0.0)
+  end
+
+  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(
+        DDMetrics::Stopwatch::NotRunningError,
+        'Cannot stop, because stopwatch is not running',
+      )
+  end
+
+  it 'errors when starting when already started' do
+    stopwatch.start
+    expect { stopwatch.start }
+      .to raise_error(
+        DDMetrics::Stopwatch::AlreadyRunningError,
+        'Cannot start, because stopwatch is already running',
+      )
+  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
+
+  it 'errors when getting duration while running' do
+    stopwatch.start
+    expect { stopwatch.duration }
+      .to raise_error(
+        DDMetrics::Stopwatch::StillRunningError,
+        'Cannot get duration, because stopwatch is still running',
+      )
+  end
+end

data/spec/ddmetrics/summary_spec.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+describe DDMetrics::Summary do
+  subject(:summary) { described_class.new }
+
+  describe '#observe' do
+    context 'non-hash label' do
+      subject { summary.observe(1.23, 'WRONG UGH') }
+
+      it 'errors' do
+        expect { subject }.to raise_error(ArgumentError, 'label argument must be a hash')
+      end
+    end
+  end
+
+  describe '#get' do
+    subject { summary.get(filter: :erb) }
+
+    before do
+      summary.observe(2.1, filter: :erb)
+      summary.observe(4.1, filter: :erb)
+      summary.observe(5.3, filter: :haml)
+    end
+
+    it { is_expected.to be_a(DDMetrics::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, filter: :erb)
+      summary.observe(4.1, filter: :erb)
+      summary.observe(5.3, filter: :haml)
+    end
+
+    it { is_expected.to match_array([{ filter: :haml }, { filter: :erb }]) }
+  end
+
+  describe '#each' do
+    subject do
+      {}.tap do |res|
+        summary.each { |label, stats| res[label] = stats.avg.round(2) }
+      end
+    end
+
+    before do
+      summary.observe(2.1, filter: :erb)
+      summary.observe(4.1, filter: :erb)
+      summary.observe(5.3, filter: :haml)
+    end
+
+    it { is_expected.to eq({ filter: :haml } => 5.3, { filter: :erb } => 3.1) }
+
+    it 'is enumerable' do
+      expect(summary.map { |_label, stats| stats.sum }.sort)
+        .to eq([5.3, 2.1 + 4.1])
+    end
+  end
+
+  describe '#to_s' do
+    subject { summary.to_s }
+
+    before do
+      summary.observe(2.1, filter: :erb)
+      summary.observe(4.1, filter: :erb)
+      summary.observe(5.3, filter: :haml)
+    end
+
+    it 'returns table' do
+      expected = <<~TABLE
+                    │ count    min    .50    .90    .95    max    tot
+        ────────────┼────────────────────────────────────────────────
+         filter=erb │     2   2.10   3.10   3.90   4.00   4.10   6.20
+        filter=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/ddmetrics/table_spec.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+describe DDMetrics::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
+
+  context 'unsorted data' do
+    let(:rows) do
+      [
+        %w[name awesomeness],
+        %w[ccc highc],
+        %w[bbb highb],
+        %w[ddd highd],
+        %w[eee highe],
+        %w[aaa higha],
+      ]
+    end
+
+    example do
+      expect(table.to_s).to eq(<<~TABLE.rstrip)
+        name │ awesomeness
+        ─────┼────────────
+         aaa │       higha
+         bbb │       highb
+         ccc │       highc
+         ddd │       highd
+         eee │       highe
+      TABLE
+    end
+  end
+end