statsd-instrument 2.5.1 → 2.6.0

data/test/client_test.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+require 'statsd/instrument/client'
+
+class ClientTest < Minitest::Test
+  def setup
+    @client = StatsD::Instrument::Client.new(datagram_builder_class: StatsD::Instrument::StatsDDatagramBuilder)
+    @dogstatsd_client = StatsD::Instrument::Client.new(
+      datagram_builder_class: StatsD::Instrument::DogStatsDDatagramBuilder,
+    )
+  end
+
+  def test_capture
+    inner_datagrams = nil
+
+    @client.increment('foo')
+    outer_datagrams = @client.capture do
+      @client.increment('bar')
+      inner_datagrams = @client.capture do
+        @client.increment('baz')
+      end
+    end
+    @client.increment('quc')
+
+    assert_equal ['bar', 'baz'], outer_datagrams.map(&:name)
+    assert_equal ['baz'], inner_datagrams.map(&:name)
+  end
+
+  def test_metric_methods_return_nil
+    assert_nil @client.increment('foo')
+    assert_nil @client.measure('bar', 122.54)
+    assert_nil @client.set('baz', 123)
+    assert_nil @client.gauge('baz', 12.3)
+  end
+
+  def test_increment_with_default_value
+    datagrams = @client.capture { @client.increment('foo') }
+    assert_equal 1, datagrams.size
+    assert_equal 'foo:1|c', datagrams.first.source
+  end
+
+  def test_measure_with_value
+    datagrams = @client.capture { @client.measure('foo', 122.54) }
+    assert_equal 1, datagrams.size
+    assert_equal 'foo:122.54|ms', datagrams.first.source
+  end
+
+  def test_measure_with_block
+    Process.stubs(:clock_gettime).with(Process::CLOCK_MONOTONIC).returns(0.1, 0.2)
+    datagrams = @client.capture do
+      @client.measure('foo') {}
+    end
+    assert_equal 1, datagrams.size
+    assert_equal 'foo:100.0|ms', datagrams.first.source
+  end
+
+  def test_gauge
+    datagrams = @client.capture { @client.gauge('foo', 123) }
+    assert_equal 1, datagrams.size
+    assert_equal 'foo:123|g', datagrams.first.source
+  end
+
+  def test_set
+    datagrams = @client.capture { @client.set('foo', 12345) }
+    assert_equal 1, datagrams.size
+    assert_equal 'foo:12345|s', datagrams.first.source
+  end
+
+  def test_histogram
+    datagrams = @dogstatsd_client.capture { @dogstatsd_client.histogram('foo', 12.44) }
+    assert_equal 1, datagrams.size
+    assert_equal 'foo:12.44|h', datagrams.first.source
+  end
+
+  def test_distribution_with_value
+    datagrams = @dogstatsd_client.capture { @dogstatsd_client.distribution('foo', 12.44) }
+    assert_equal 1, datagrams.size
+    assert_equal 'foo:12.44|d', datagrams.first.source
+  end
+
+  def test_distribution_with_block
+    Process.stubs(:clock_gettime).with(Process::CLOCK_MONOTONIC).returns(0.1, 0.2)
+    datagrams = @dogstatsd_client.capture do
+      @dogstatsd_client.distribution('foo') {}
+    end
+    assert_equal 1, datagrams.size
+    assert_equal "foo:100.0|d", datagrams.first.source
+  end
+
+  def test_latency_emits_ms_metric
+    Process.stubs(:clock_gettime).with(Process::CLOCK_MONOTONIC).returns(0.1, 0.2)
+    datagrams = @client.capture do
+      @client.latency('foo') {}
+    end
+    assert_equal 1, datagrams.size
+    assert_equal "foo:100.0|ms", datagrams.first.source
+  end
+
+  def test_latency_on_dogstatsd_prefers_distribution_metric_type
+    Process.stubs(:clock_gettime).with(Process::CLOCK_MONOTONIC).returns(0.1, 0.2)
+    datagrams = @dogstatsd_client.capture do
+      @dogstatsd_client.latency('foo') {}
+    end
+    assert_equal 1, datagrams.size
+    assert_equal "foo:100.0|d", datagrams.first.source
+  end
+
+  def test_latency_calls_block_even_when_not_sending_a_sample
+    called = false
+    @client.capture do
+      @client.latency('foo', sample_rate: 0) { called = true }
+    end
+    assert called, "The block should have been called"
+  end
+
+  def test_service_check
+    datagrams = @dogstatsd_client.capture { @dogstatsd_client.service_check('service', :ok) }
+    assert_equal 1, datagrams.size
+    assert_equal "_sc|service|0", datagrams.first.source
+  end
+
+  def test_event
+    datagrams = @dogstatsd_client.capture { @dogstatsd_client.event('service', "event\ndescription") }
+    assert_equal 1, datagrams.size
+    assert_equal "_e{7,18}:service|event\\ndescription", datagrams.first.source
+  end
+
+  def test_no_prefix
+    client = StatsD::Instrument::Client.new(prefix: 'foo')
+    datagrams = client.capture do
+      client.increment('bar')
+      client.increment('bar', no_prefix: true)
+    end
+
+    assert_equal 2, datagrams.size
+    assert_equal "foo.bar", datagrams[0].name
+    assert_equal "bar", datagrams[1].name
+  end
+
+  def test_sampling
+    mock_sink = mock('sink')
+    mock_sink.stubs(:sample?).returns(false, true, false, false, true)
+    mock_sink.expects(:<<).twice
+
+    client = StatsD::Instrument::Client.new(sink: mock_sink)
+    5.times { client.increment('metric') }
+  end
+
+  def test_clone_with_prefix_option
+    # Both clients will use the same sink.
+    mock_sink = mock('sink')
+    mock_sink.stubs(:sample?).returns(true)
+    mock_sink.expects(:<<).with("metric:1|c").returns(mock_sink)
+    mock_sink.expects(:<<).with("foo.metric:1|c").returns(mock_sink)
+
+    original_client = StatsD::Instrument::Client.new(sink: mock_sink)
+    client_with_other_options = original_client.clone_with_options(prefix: 'foo')
+
+    original_client.increment('metric')
+    client_with_other_options.increment('metric')
+  end
+end

data/test/compatibility/dogstatsd_datagram_compatibility_test.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'statsd/instrument/client'
+
+module Compatibility
+  class DogStatsDDatagramCompatibilityTest < Minitest::Test
+    def setup
+      StatsD::Instrument::UDPSink.any_instance.stubs(:sample?).returns(true)
+      StatsD::Instrument::Backends::UDPBackend.any_instance.stubs(:rand).returns(0)
+
+      @server = UDPSocket.new
+      @server.bind('localhost', 0)
+      @host = @server.addr[2]
+      @port = @server.addr[1]
+    end
+
+    def teardown
+      @server.close
+    end
+
+    def test_increment_compatibility
+      assert_equal_datagrams { |client| client.increment('counter') }
+      assert_equal_datagrams { |client| client.increment('counter', no_prefix: true) }
+      assert_equal_datagrams { |client| client.increment('counter', 12) }
+      assert_equal_datagrams { |client| client.increment('counter', sample_rate: 0.1) }
+      assert_equal_datagrams { |client| client.increment('counter', tags: ['foo', 'bar']) }
+      assert_equal_datagrams { |client| client.increment('counter', tags: { foo: 'bar' }) }
+      assert_equal_datagrams { |client| client.increment('counter', sample_rate: 0.1, tags: ['quc']) }
+    end
+
+    def test_measure_compatibility
+      assert_equal_datagrams { |client| client.measure('timing', 12.34) }
+      assert_equal_datagrams { |client| client.measure('timing', 0.01, no_prefix: true) }
+      assert_equal_datagrams { |client| client.measure('timing', 0.12, sample_rate: 0.1) }
+      assert_equal_datagrams { |client| client.measure('timing', 0.12, tags: ['foo', 'bar']) }
+    end
+
+    def test_measure_with_block_compatibility
+      Process.stubs(:clock_gettime).with(Process::CLOCK_MONOTONIC).returns(12.1)
+      assert_equal_datagrams do |client|
+        return_value = client.measure('timing', tags: ['foo'], sample_rate: 0.1) { 'foo' }
+        assert_equal 'foo', return_value
+      end
+    end
+
+    def test_gauge_compatibility
+      assert_equal_datagrams { |client| client.gauge('current', 1234) }
+      assert_equal_datagrams { |client| client.gauge('current', 1234, no_prefix: true) }
+      assert_equal_datagrams { |client| client.gauge('current', 1234, sample_rate: 0.1) }
+      assert_equal_datagrams { |client| client.gauge('current', 1234, tags: ['foo', 'bar']) }
+      assert_equal_datagrams { |client| client.gauge('current', 1234, tags: { foo: 'bar' }) }
+      assert_equal_datagrams { |client| client.gauge('current', 1234, sample_rate: 0.1, tags: ['quc']) }
+    end
+
+    def test_set_compatibility
+      assert_equal_datagrams { |client| client.set('unique', 'foo') }
+      assert_equal_datagrams { |client| client.set('unique', 'foo', no_prefix: true) }
+      assert_equal_datagrams { |client| client.set('unique', 'foo', sample_rate: 0.1) }
+      assert_equal_datagrams { |client| client.set('unique', '1234', tags: ['foo', 'bar']) }
+      assert_equal_datagrams { |client| client.set('unique', '1234', tags: { foo: 'bar' }) }
+      assert_equal_datagrams { |client| client.set('unique', '1234', sample_rate: 0.1, tags: ['quc']) }
+    end
+
+    def test_histogram_compatibility
+      assert_equal_datagrams { |client| client.histogram('sample', 12.44) }
+      assert_equal_datagrams { |client| client.histogram('sample', 12.44, no_prefix: true) }
+      assert_equal_datagrams { |client| client.histogram('sample', 12.44, sample_rate: 0.1) }
+      assert_equal_datagrams { |client| client.histogram('sample', 12.44, tags: ['foo', 'bar']) }
+      assert_equal_datagrams { |client| client.histogram('sample', 12.44, tags: { foo: 'bar' }) }
+      assert_equal_datagrams { |client| client.histogram('sample', 12.44, sample_rate: 0.1, tags: ['quc']) }
+    end
+
+    def test_distribution_compatibility
+      assert_equal_datagrams { |client| client.distribution('sample', 12.44) }
+      assert_equal_datagrams { |client| client.distribution('sample', 12.44, no_prefix: true) }
+      assert_equal_datagrams { |client| client.distribution('sample', 12.44, sample_rate: 0.1) }
+      assert_equal_datagrams { |client| client.distribution('sample', 12.44, tags: ['foo', 'bar']) }
+      assert_equal_datagrams { |client| client.distribution('sample', 12.44, tags: { foo: 'bar' }) }
+      assert_equal_datagrams { |client| client.distribution('sample', 12.44, sample_rate: 0.1, tags: ['quc']) }
+    end
+
+    def test_distribution_with_block_compatibility
+      Process.stubs(:clock_gettime).with(Process::CLOCK_MONOTONIC).returns(12.1)
+      assert_equal_datagrams do |client|
+        return_value = client.distribution('timing', tags: ['foo'], sample_rate: 0.1) { 'foo' }
+        assert_equal 'foo', return_value
+      end
+    end
+
+    def test_service_check_compatibility
+      assert_equal_datagrams { |client| client.service_check('service', 0) }
+      assert_equal_datagrams { |client| client.service_check('service', :critical, no_prefix: true) }
+      assert_equal_datagrams { |client| client.event('foo', "bar\nbaz") }
+      assert_equal_datagrams do |client|
+        client.service_check('service', "ok", timestamp: Time.parse('2019-09-09T04:22:17Z'),
+          hostname: 'localhost', tags: ['foo'], message: 'bar')
+      end
+    end
+
+    def test_event_compatibility
+      assert_equal_datagrams { |client| client.event('foo', "bar\nbaz") }
+      assert_equal_datagrams { |client| client.event('foo', "bar\nbaz", no_prefix: true) }
+      assert_equal_datagrams do |client|
+        client.event('Something happend', "And it's not good", timestamp: Time.parse('2019-09-09T04:22:17Z'),
+          hostname: 'localhost', tags: ['foo'], alert_type: 'warning', priority: 'low',
+          aggregation_key: 'foo', source_type_name: 'logs')
+      end
+    end
+
+    private
+
+    MODES = [:normal, :with_prefix, :with_default_tags]
+
+    def assert_equal_datagrams(&block)
+      MODES.each do |mode|
+        legacy_datagram = with_legacy_client(mode) { |client| read_datagram(client, &block) }
+        new_datagram = with_new_client(mode) { |client| read_datagram(client, &block) }
+
+        assert_equal legacy_datagram, new_datagram, "The datagrams emitted were not the same in #{mode} mode"
+      end
+    end
+
+    def with_legacy_client(mode)
+      old_prefix = StatsD.prefix
+      StatsD.prefix = 'prefix' if mode == :with_prefix
+
+      old_default_tags = StatsD.default_tags
+      StatsD.default_tags = { key: 'value' } if mode == :with_default_tags
+
+      old_backend = StatsD.backend
+      new_backend = StatsD::Instrument::Backends::UDPBackend.new("#{@host}:#{@port}", :datadog)
+      StatsD.backend = new_backend
+
+      yield(StatsD)
+    ensure
+      new_backend.socket.close if new_backend&.socket
+      StatsD.backend = old_backend
+      StatsD.prefix = old_prefix
+      StatsD.default_tags = old_default_tags
+    end
+
+    def with_new_client(mode)
+      prefix = mode == :with_prefix ? 'prefix' : nil
+      default_tags = mode == :with_default_tags ? { key: 'value' } : nil
+      client = StatsD::Instrument::Client.new(
+        sink: StatsD::Instrument::UDPSink.new(@host, @port),
+        datagram_builder_class: StatsD::Instrument::DogStatsDDatagramBuilder,
+        prefix: prefix,
+        default_tags: default_tags
+      )
+
+      yield(client)
+    end
+
+    def read_datagram(client)
+      yield(client)
+      data, _origin = @server.recvfrom(100)
+      data
+    end
+  end
+end

data/test/datagram_builder_test.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+require 'statsd/instrument/client'
+
+class DatagramBuilderTest < Minitest::Test
+  def setup
+    @datagram_builder = StatsD::Instrument::DatagramBuilder.new
+  end
+
+  def test_normalize_name
+    assert_equal 'foo', @datagram_builder.send(:normalize_name, 'foo')
+    assert_equal 'fo_o', @datagram_builder.send(:normalize_name, 'fo|o')
+    assert_equal 'fo_o', @datagram_builder.send(:normalize_name, 'fo@o')
+    assert_equal 'fo_o', @datagram_builder.send(:normalize_name, 'fo:o')
+  end
+
+  def test_normalize_unsupported_tag_names
+    assert_equal ['ignored'], @datagram_builder.send(:normalize_tags, ['igno|re,d'])
+    # Note: how this is interpreted by the backend is undefined.
+    # We rely on the user to not do stuff like this if they don't want to be surprised.
+    # We do not want to take the performance hit of normaling this.
+    assert_equal ['lol::class:omg::lol'], @datagram_builder.send(:normalize_tags, "lol::class" => "omg::lol")
+  end
+
+  def test_normalize_tags_converts_hash_to_array
+    assert_equal ['tag:value'], @datagram_builder.send(:normalize_tags, tag: 'value')
+    assert_equal ['tag1:v1', 'tag2:v2'], @datagram_builder.send(:normalize_tags, tag1: 'v1', tag2: 'v2')
+  end
+
+  def test_c
+    datagram = @datagram_builder.c('foo', 1, nil, nil)
+    assert_equal "foo:1|c", datagram
+
+    datagram = @datagram_builder.c('fo:o', 10, 0.1, nil)
+    assert_equal "fo_o:10|c|@0.1", datagram
+  end
+
+  def test_ms
+    datagram = @datagram_builder.ms('foo', 1, nil, nil)
+    assert_equal "foo:1|ms", datagram
+
+    datagram = @datagram_builder.ms('fo:o', 10, 0.1, nil)
+    assert_equal "fo_o:10|ms|@0.1", datagram
+  end
+
+  def test_g
+    datagram = @datagram_builder.g('foo', 1, nil, nil)
+    assert_equal "foo:1|g", datagram
+
+    datagram = @datagram_builder.g('fo|o', 10, 0.01, nil)
+    assert_equal "fo_o:10|g|@0.01", datagram
+  end
+
+  def test_s
+    datagram = @datagram_builder.s('foo', 1, nil, nil)
+    assert_equal "foo:1|s", datagram
+
+    datagram = @datagram_builder.s('fo@o', 10, 0.01, nil)
+    assert_equal "fo_o:10|s|@0.01", datagram
+  end
+
+  def test_h
+    datagram = @datagram_builder.h('foo', 1, nil, nil)
+    assert_equal "foo:1|h", datagram
+
+    datagram = @datagram_builder.h('fo@o', 10, 0.01, nil)
+    assert_equal "fo_o:10|h|@0.01", datagram
+  end
+
+  def test_d
+    datagram = @datagram_builder.d('foo', 1, nil, nil)
+    assert_equal "foo:1|d", datagram
+
+    datagram = @datagram_builder.d('fo@o', 10, 0.01, nil)
+    assert_equal "fo_o:10|d|@0.01", datagram
+  end
+
+  def test_tags
+    datagram = @datagram_builder.d('foo', 10, nil, ['foo', 'bar'])
+    assert_equal "foo:10|d|#foo,bar", datagram
+
+    datagram = @datagram_builder.d('foo', 10, 0.1, ['foo:bar'])
+    assert_equal "foo:10|d|@0.1|#foo:bar", datagram
+
+    datagram = @datagram_builder.d('foo', 10, 1, foo: 'bar', baz: 'quc')
+    assert_equal "foo:10|d|#foo:bar,baz:quc", datagram
+  end
+
+  def test_prefix
+    datagram_builder = StatsD::Instrument::DatagramBuilder.new(prefix: 'foo')
+    datagram = datagram_builder.c('bar', 1, nil, nil)
+    assert_equal 'foo.bar:1|c', datagram
+
+    # The prefix should also be normalized
+    datagram_builder = StatsD::Instrument::DatagramBuilder.new(prefix: 'foo|bar')
+    datagram = datagram_builder.c('baz', 1, nil, nil)
+    assert_equal 'foo_bar.baz:1|c', datagram
+  end
+
+  def test_default_tags
+    datagram_builder = StatsD::Instrument::DatagramBuilder.new(default_tags: ['foo'])
+    datagram = datagram_builder.c('bar', 1, nil, nil)
+    assert_equal 'bar:1|c|#foo', datagram
+
+    datagram = datagram_builder.c('bar', 1, nil, a: 'b')
+    assert_equal 'bar:1|c|#a:b,foo', datagram
+
+    # We do not filter out duplicates, because detecting dupes is too time consuming.
+    # We let the server deal with the situation
+    datagram = datagram_builder.c('bar', 1, nil, ['foo'])
+    assert_equal 'bar:1|c|#foo,foo', datagram
+
+    # Default tags are also normalized
+    datagram_builder = StatsD::Instrument::DatagramBuilder.new(default_tags: ['f,o|o'])
+    datagram = datagram_builder.c('bar', 1, nil, nil)
+    assert_equal 'bar:1|c|#foo', datagram
+  end
+end

data/test/deprecations_test.rb

@@ -4,13 +4,13 @@ require 'test_helper'
 
 class DeprecationsTest < Minitest::Test
   unless StatsD::Instrument.strict_mode_enabled?
-    # rubocop:disable StatsD/MetaprogrammingPositionalArguments
     class InstrumentedClass
       extend StatsD::Instrument
       def foo; end
-      statsd_count :foo, 'metric', 0.5, ['tag']
+      statsd_count :foo, 'frequency', 0.5, ['tag'] # rubocop:disable StatsD/MetaprogrammingPositionalArguments
+      statsd_measure :foo, 'latency', as_dist: true # rubocop:disable StatsD/MeasureAsDistArgument
+      statsd_count_success :foo, 'frequency', prefix: 'foo' # rubocop:disable StatsD/MetricPrefixArgument
     end
-    # rubocop:enable StatsD/MetaprogrammingPositionalArguments
   end
 
   include StatsD::Instrument::Assertions
@@ -19,6 +19,30 @@ class DeprecationsTest < Minitest::Test
     skip("Deprecation are not supported in strict mode") if StatsD::Instrument.strict_mode_enabled?
   end
 
+  def test__deprecated__metaprogramming_method_with_positional_arguments
+    metrics = capture_statsd_calls { InstrumentedClass.new.foo }
+    metric = metrics[0]
+    assert_equal :c, metric.type
+    assert_equal 'frequency', metric.name
+    assert_equal 1, metric.value
+    assert_equal 0.5, metric.sample_rate
+    assert_equal ["tag"], metric.tags
+  end
+
+  def test__deprecated__metaprogramming_statsd_measure_with_as_dist
+    metrics = capture_statsd_calls { InstrumentedClass.new.foo }
+    metric = metrics[1]
+    assert_equal :d, metric.type
+    assert_equal 'latency', metric.name
+  end
+
+  def test__deprecated__metaprogramming_statsd_count_with_prefix
+    metrics = capture_statsd_calls { InstrumentedClass.new.foo }
+    metric = metrics[2]
+    assert_equal :c, metric.type
+    assert_equal 'foo.frequency.success', metric.name
+  end
+
   # rubocop:disable StatsD/MetricValueKeywordArgument
   def test__deprecated__statsd_measure_with_explicit_value_as_keyword_argument
     metric = capture_statsd_call { StatsD.measure('values.foobar', value: 42) }
@@ -27,11 +51,13 @@ class DeprecationsTest < Minitest::Test
     assert_equal :ms, metric.type
   end
 
+  # rubocop:disable StatsD/MeasureAsDistArgument
   def test__deprecated__statsd_measure_with_explicit_value_keyword_and_distribution_override
     metric = capture_statsd_call { StatsD.measure('values.foobar', value: 42, as_dist: true) }
     assert_equal 42, metric.value
     assert_equal :d, metric.type
   end
+  # rubocop:enable StatsD/MeasureAsDistArgument
 
   def test__deprecated__statsd_increment_with_value_as_keyword_argument
     metric = capture_statsd_call { StatsD.increment('values.foobar', value: 2) }
@@ -67,14 +93,34 @@ class DeprecationsTest < Minitest::Test
   end
   # rubocop:enable StatsD/PositionalArguments
 
-  def test__deprecated__metaprogramming_method_with_positional_arguments
-    metric = capture_statsd_call { InstrumentedClass.new.foo }
-    assert_equal :c, metric.type
-    assert_equal 'metric', metric.name
-    assert_equal 1, metric.value
-    assert_equal 0.5, metric.sample_rate
-    assert_equal ["tag"], metric.tags
+  # rubocop:disable StatsD/MeasureAsDistArgument
+  def test__deprecated__statsd_measure_with_explicit_value_and_distribution_override
+    metric = capture_statsd_call { StatsD.measure('values.foobar', 42, as_dist: true) }
+    assert_equal :d, metric.type
+  end
+
+  def test__deprecated__statsd_measure_use_distribution_override_for_a_block
+    metric = capture_statsd_call do
+      StatsD.measure('values.foobar', as_dist: true) { 'foo' }
+    end
+    assert_equal :d, metric.type
+  end
+
+  def test__deprecated__statsd_measure_as_distribution_returns_return_value_of_block_even_if_nil
+    return_value = StatsD.measure('values.foobar', as_dist: true) { nil }
+    assert_nil return_value
+  end
+  # rubocop:enable StatsD/MeasureAsDistArgument
+
+  # rubocop:disable StatsD/MetricPrefixArgument
+  def test__deprecated__override_name_prefix
+    m = capture_statsd_call { StatsD.increment('counter', prefix: "foobar") }
+    assert_equal 'foobar.counter', m.name
+
+    m = capture_statsd_call { StatsD.increment('counter', prefix: "foobar", no_prefix: true) }
+    assert_equal 'counter', m.name
   end
+  # rubocop:enable StatsD/MetricPrefixArgument
 
   protected
 

data/test/dogstatsd_datagram_builder_test.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+require 'statsd/instrument/client'
+
+class DogStatsDDatagramBuilderTest < Minitest::Test
+  def setup
+    @datagram_builder = StatsD::Instrument::DogStatsDDatagramBuilder.new
+  end
+
+  def test_raises_on_unsupported_metrics
+    assert_raises(NotImplementedError) { @datagram_builder.kv('foo', 10, nil, nil) }
+  end
+
+  def test_service_check
+    assert_equal '_sc|service|0', @datagram_builder._sc('service', :ok)
+    datagram = @datagram_builder._sc('service', :warning, timestamp: Time.parse('2019-09-30T04:22:12Z'),
+      hostname: 'localhost', tags: { foo: 'bar|baz' }, message: 'blah')
+    assert_equal "_sc|service|1|h:localhost|d:1569817332|#foo:barbaz|m:blah", datagram
+  end
+
+  def test_event
+    assert_equal '_e{5,5}:hello|world', @datagram_builder._e('hello', "world")
+
+    datagram = @datagram_builder._e("testing", "with\nnewline", timestamp: Time.parse('2019-09-30T04:22:12Z'),
+      hostname: 'localhost', aggregation_key: 'my-key', priority: 'low', source_type_name: 'source',
+      alert_type: 'success', tags: { foo: 'bar|baz' })
+    assert_equal '_e{7,13}:testing|with\\nnewline|h:localhost|d:1569817332|k:my-key|' \
+      'p:low|s:source|t:success|#foo:barbaz', datagram
+  end
+end