loggregator_emitter 5.0.1 → 5.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0d1ef9bf97fbc5930c29130a377344fa40b1264b
-  data.tar.gz: 9fd666bb99d2120fa012cb2f372e17a8f335de35
+  metadata.gz: ce623535025497b97a8f11adcae61e83d3da8f97
+  data.tar.gz: edaff20710aef2d52d43ea383c808cbd21f86349
 SHA512:
-  metadata.gz: 800c01ae3b281d7738fac0c5473a3f28a15d9a7c9cf4a52a6b2d4381888e116c4532c1ea9786e1e02cc52f421e24a282ebcba8b29755dd426e232ed9c83da7e6
-  data.tar.gz: 80df9ff95e024d76be537843d3c70cf725b8366ca6c64ff02a5396ab698bc8385a1e571c11724d8790c1d6cef47af21b4ef6c1eef8151f8708c90bad0059f0fa
+  metadata.gz: 2a19fe40d7843694e3e12c35e0928355ab56f83703838766460ec573533980445a4e4270e2db5e0f81e07ec64091b6572d1f2d84fafdde868b5f98c233b607df
+  data.tar.gz: c037d51137815da7e2c1d6b0a541d9c5f1ef4524b35d87df326dbe578c96aeb7f47dd88ea78f4fda86aa3a17ed66a8898ae352f44c6883e9323f8d9709b4fd39

data/.travis.yml

@@ -1,10 +1,15 @@
 notifications:
   email:
   - cf-loggregator@pivotallabs.com
+
+sudo: required
+dist: precise
+group: legacy
 language: ruby
+
 rvm:
-- 1.9.3
 - 2.0.0
+- 2.3.0
 script:
 - bundle exec rake nonperformance
 - DISABLE_COVERAGE=true bundle exec rake performance

data/README.md

@@ -12,12 +12,12 @@ Call emit() or emit_error() on this emitter with the application GUID and the me
 
 ##### A valid source name is any 3 character string.   Some common component sources are:
 
- 	API (Cloud Controller)
- 	RTR (Go Router)
- 	UAA
- 	DEA
- 	APP (Warden container)
- 	LGR (Loggregator)
+    API (Cloud Controller)
+    RTR (Go Router)
+    UAA
+    DEA
+    APP (Warden container)
+    LGR (Loggregator)
 
 ### Setup
 
@@ -33,9 +33,11 @@ Call emit() or emit_error() on this emitter with the application GUID and the me
 
     app_guid = "a8977cb6-3365-4be1-907e-0c878b3a4c6b" # The GUID(UUID) for the user's application
 
-    emitter.emit(app_guid,message) # Emits messages with a message type of OUT
+    emitter.emit(app_guid, message) # Emits messages with a message type of OUT
 
-    emitter.emit_error(app_guid,error_message) # Emits messages with a message type of ERR
+    emitter.emit(app_guid, message, {"key" => "value"}) # Emits messages with tags
+
+    emitter.emit_error(app_guid, error_message) # Emits messages with a message type of ERR
 
 ### Regenerating Protobuf library
 

data/lib/loggregator_emitter/emit.rb

@@ -16,7 +16,7 @@ module LoggregatorEmitter
       @host, @port = loggregator_server.split(/:([^:]*$)/)
 
       raise ArgumentError, "Must provide valid loggregator server: #{loggregator_server}" if !valid_hostname || !valid_port
-      @host = ::Resolv.getaddresses(@host).last
+      @host = ::Resolv.getaddresses(@host).first
       raise ArgumentError, "Must provide valid loggregator server: #{loggregator_server}" unless @host
 
       raise ArgumentError, "Must provide a valid origin" unless origin
@@ -30,12 +30,30 @@ module LoggregatorEmitter
       @source_instance = source_instance && source_instance.to_s
     end
 
-    def emit(app_id, message)
-      emit_message(app_id, message, LogMessage::MessageType::OUT)
+    def emit(app_id, message, tags = nil)
+      emit_message(app_id, message, LogMessage::MessageType::OUT, tags)
     end
 
-    def emit_error(app_id, message)
-      emit_message(app_id, message, LogMessage::MessageType::ERR)
+    def emit_error(app_id, message, tags = nil)
+      emit_message(app_id, message, LogMessage::MessageType::ERR, tags)
+    end
+
+    def emit_value_metric(name, value, unit, tags = nil)
+      return unless name && value && unit
+
+      send_protobuffer(create_value_metric_envelope(name, value, unit, tags))
+    end
+
+    def emit_counter(name, delta, tags = nil)
+      return unless name && delta
+
+      send_protobuffer(create_counter_envelope(name, delta, tags))
+    end
+
+    def emit_container_metric(app_id, instanceIndex, cpu, memory, disk, tags = nil)
+      return unless app_id && instanceIndex && cpu && memory && disk
+
+      send_protobuffer(create_container_metric_envelope(app_id, instanceIndex, cpu, memory, disk, tags))
     end
 
     private
@@ -52,7 +70,15 @@ module LoggregatorEmitter
       message.split(/\n|\r/).reject { |a| a.empty? }
     end
 
-    def emit_message(app_id, message, type)
+    def set_tags(tags)
+      envelope_tags = []
+      tags.each do |k, v|
+        envelope_tags << ::Sonde::Envelope::TagsEntry.new(:key => k, :value => v)
+      end
+      envelope_tags
+    end
+
+    def emit_message(app_id, message, type, tags = nil)
       return unless app_id && message && message.strip.length > 0
 
       split_message(message).each do |m|
@@ -60,13 +86,13 @@ module LoggregatorEmitter
           m = m.byteslice(0, MAX_MESSAGE_BYTE_SIZE-TRUNCATED_STRING.bytesize) + TRUNCATED_STRING
         end
 
-        send_protobuffer(create_log_envelope(app_id, m, type))
+        send_protobuffer(create_log_envelope(app_id, m, type, tags))
       end
     end
 
-    def create_log_message(app_id, message, type)
+    def create_log_message(app_id, message, type, time)
       lm = ::Sonde::LogMessage.new()
-      lm.time = Time.now
+      lm.time = time
       lm.message = message
       lm.app_id = app_id
       lm.source_instance = @source_instance
@@ -75,14 +101,79 @@ module LoggregatorEmitter
       lm
     end
 
-    def create_log_envelope(app_id, message, type)
+    def create_log_envelope(app_id, message, type, tags = nil)
       le = ::Sonde::Envelope.new()
       le.origin = @origin
+      le.time = Time.now
       le.eventType = ::Sonde::Envelope::EventType::LogMessage
-      le.logMessage = create_log_message(app_id, message, type)
+      le.logMessage = create_log_message(app_id, message, type, le.time)
+      if tags != nil
+        le.tags = set_tags(tags)
+      end
       le
     end
 
+    def create_value_metric(name, value, unit)
+      metric = ::Sonde::ValueMetric.new()
+      metric.name = name
+      metric.value = value
+      metric.unit = unit
+      metric
+    end
+
+    def create_value_metric_envelope(name, value, unit, tags = nil)
+      envelope = ::Sonde::Envelope.new()
+      envelope.time = Time.now
+      envelope.origin = @origin
+      envelope.eventType = ::Sonde::Envelope::EventType::ValueMetric
+      envelope.valueMetric = create_value_metric(name, value, unit)
+      if tags != nil
+        envelope.tags = set_tags(tags)
+      end
+      envelope
+    end
+
+    def create_counter_event(name, delta)
+      counter = ::Sonde::CounterEvent.new()
+      counter.name = name
+      counter.delta = delta
+      counter
+    end
+
+    def create_counter_envelope(name, delta, tags = nil)
+      envelope = ::Sonde::Envelope.new()
+      envelope.time = Time.now
+      envelope.origin = @origin
+      envelope.eventType = ::Sonde::Envelope::EventType::CounterEvent
+      envelope.counterEvent = create_counter_event(name, delta)
+      if tags != nil
+        envelope.tags = set_tags(tags)
+      end
+      envelope
+    end
+
+    def create_container_metric(app_id, instanceIndex, cpu, memory, disk)
+      metric = ::Sonde::ContainerMetric.new()
+      metric.applicationId = app_id
+      metric.instanceIndex = instanceIndex
+      metric.cpuPercentage = cpu
+      metric.memoryBytes = memory
+      metric.diskBytes = disk
+      metric
+    end
+
+    def create_container_metric_envelope(app_id, instanceIndex, cpu, memory, disk, tags = nil)
+      envelope = ::Sonde::Envelope.new()
+      envelope.time = Time.now
+      envelope.origin = @origin
+      envelope.eventType = ::Sonde::Envelope::EventType::ContainerMetric
+      envelope.containerMetric = create_container_metric(app_id, instanceIndex, cpu, memory, disk)
+      if tags != nil
+        envelope.tags = set_tags(tags)
+      end
+      envelope
+    end
+
     def send_protobuffer(lm)
       result = lm.encode.buf
       result.unpack("C*")

data/lib/sonde/envelope.pb.rb

@@ -7,8 +7,6 @@ module Sonde
     include Beefcake::Message
 
     module EventType
-      HttpStart = 2
-      HttpStop = 3
       HttpStartStop = 4
       LogMessage = 5
       ValueMetric = 6
@@ -16,9 +14,18 @@ module Sonde
       Error = 8
       ContainerMetric = 9
     end
+
+    class TagsEntry
+      include Beefcake::Message
+    end
   end
 
   class Envelope
+
+    class TagsEntry
+      optional :key, :string, 1
+      optional :value, :string, 2
+    end
     required :origin, :string, 1
     required :eventType, Envelope::EventType, 2
     optional :timestamp, :int64, 6
@@ -26,8 +33,7 @@ module Sonde
     optional :job, :string, 14
     optional :index, :string, 15
     optional :ip, :string, 16
-    optional :httpStart, HttpStart, 4
-    optional :httpStop, HttpStop, 5
+    repeated :tags, Envelope::TagsEntry, 17
     optional :httpStartStop, HttpStartStop, 7
     optional :logMessage, LogMessage, 8
     optional :valueMetric, ValueMetric, 9

data/lib/sonde/http.pb.rb

@@ -55,42 +55,10 @@ module Sonde
     VERSION_CONTROL = 44
   end
 
-  class HttpStart
-    include Beefcake::Message
-  end
-
-  class HttpStop
-    include Beefcake::Message
-  end
-
   class HttpStartStop
     include Beefcake::Message
   end
 
-  class HttpStart
-    required :timestamp, :int64, 1
-    required :requestId, UUID, 2
-    required :peerType, PeerType, 3
-    required :method, Method, 4
-    required :uri, :string, 5
-    required :remoteAddress, :string, 6
-    required :userAgent, :string, 7
-    optional :parentRequestId, UUID, 8
-    optional :applicationId, UUID, 9
-    optional :instanceIndex, :int32, 10
-    optional :instanceId, :string, 11
-  end
-
-  class HttpStop
-    required :timestamp, :int64, 1
-    required :uri, :string, 2
-    required :requestId, UUID, 3
-    required :peerType, PeerType, 4
-    required :statusCode, :int32, 5
-    required :contentLength, :int64, 6
-    optional :applicationId, UUID, 7
-  end
-
   class HttpStartStop
     required :startTimestamp, :int64, 1
     required :stopTimestamp, :int64, 2
@@ -102,9 +70,9 @@ module Sonde
     required :userAgent, :string, 8
     required :statusCode, :int32, 9
     required :contentLength, :int64, 10
-    optional :parentRequestId, UUID, 11
     optional :applicationId, UUID, 12
     optional :instanceIndex, :int32, 13
     optional :instanceId, :string, 14
+    repeated :forwarded, :string, 15
   end
 end

data/lib/sonde/metric.pb.rb

@@ -33,5 +33,7 @@ module Sonde
     required :cpuPercentage, :double, 3
     required :memoryBytes, :uint64, 4
     required :diskBytes, :uint64, 5
+    optional :memoryBytesQuota, :uint64, 6
+    optional :diskBytesQuota, :uint64, 7
   end
 end

data/lib/sonde/sonde_extender.rb

@@ -14,4 +14,16 @@ module Sonde
       Time.at(num_secs, fractional_usecs)
     end
   end
-end
+
+  class Envelope
+    def time=(time)
+      self.timestamp = (time.tv_sec * 1000000000) + time.tv_nsec
+    end
+
+    def time
+      num_secs = @timestamp / 1000000000
+      fractional_usecs = (@timestamp % 1000000000).to_f / 1000
+      Time.at(num_secs, fractional_usecs)
+    end
+  end
+end

data/loggregator_emitter.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |spec|
   spec.name          = "loggregator_emitter"
-  spec.version       = '5.0.1'
+  spec.version       = '5.1.1'
   spec.authors       = ["Pivotal"]
   spec.email         = ["cf-eng@pivotallabs.com"]
   spec.description   = "Library to emit data to Loggregator"
@@ -15,12 +15,13 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(spec)/})
   spec.require_paths = ["lib"]
 
-  spec.required_ruby_version = Gem::Requirement.new(">= 1.9.3")
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.0.0")
 
   spec.add_dependency "beefcake", "~> 1.0.0"
 
   spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "coveralls", "~> 0.8", ">= 0.8.14"
   spec.add_development_dependency "rake"
-  spec.add_development_dependency "rspec", "~> 2.14.1"
-  spec.add_development_dependency "coveralls"
+  spec.add_development_dependency "rspec", "~> 2.14", ">= 2.14.1"
+  spec.add_development_dependency "timecop"
 end

data/spec/loggregator_emitter/emit_spec.rb

@@ -6,7 +6,7 @@ require "loggregator_emitter"
 describe LoggregatorEmitter do
 
   before :all do
-    @free_port = 12345
+    @free_port = test_port
     @server = FakeLoggregatorServer.new(@free_port)
     @server.start
   end
@@ -19,68 +19,84 @@ describe LoggregatorEmitter do
     @server.reset
   end
 
+  def test_port
+    server = TCPServer.new('localhost', 0)
+    server.addr[1]
+  end
+
   describe "configuring emitter" do
     describe "valid configurations" do
       it "is valid with IP and proper source name" do
-        expect { LoggregatorEmitter::Emitter.new("0.0.0.0:12345", "origin", "DEA") }.not_to raise_error
+        expect { LoggregatorEmitter::Emitter.new("0.0.0.0:#{@free_port}", "origin", "DEA") }.not_to raise_error
       end
 
       it "is valid with resolveable hostname and proper source name" do
-        expect { LoggregatorEmitter::Emitter.new("localhost:12345", "origin", "DEA") }.not_to raise_error
+        expect { LoggregatorEmitter::Emitter.new("localhost:#{@free_port}", "origin", "DEA") }.not_to raise_error
       end
 
       it "accepts a string as source type/name" do
-        expect { LoggregatorEmitter::Emitter.new("localhost:12345", "origin", "STG") }.not_to raise_error
+        expect { LoggregatorEmitter::Emitter.new("localhost:#{@free_port}", "origin", "STG") }.not_to raise_error
       end
     end
 
     describe "invalid configurations" do
       describe "error based on loggregator_server" do
         it "raises if host has protocol" do
-          expect { LoggregatorEmitter::Emitter.new("http://0.0.0.0:12345", "origin", "DEA") }.to raise_error(ArgumentError)
+          expect { LoggregatorEmitter::Emitter.new("http://0.0.0.0:#{@free_port}", "origin", "DEA") }.to raise_error(ArgumentError)
         end
 
         it "raises if host is blank" do
-          expect { LoggregatorEmitter::Emitter.new(":12345", "origin", "DEA") }.to raise_error(ArgumentError)
+          expect { LoggregatorEmitter::Emitter.new(":#{@free_port}", "origin", "DEA") }.to raise_error(ArgumentError)
         end
 
         it "raises if host is unresolvable" do
-          expect { LoggregatorEmitter::Emitter.new("i.cant.resolve.foo:12345", "origin", "DEA") }.to raise_error(ArgumentError)
+          expect { LoggregatorEmitter::Emitter.new("i.cant.resolve.foo:#{@free_port}", "origin", "DEA") }.to raise_error(ArgumentError)
         end
 
         it "raises if origin is blank" do
-          expect { LoggregatorEmitter::Emitter.new(":12345", "", "DEA") }.to raise_error(ArgumentError)
+          expect { LoggregatorEmitter::Emitter.new(":#{@free_port}", "", "DEA") }.to raise_error(ArgumentError)
         end
 
         it "raises if source_type is an unknown integer" do
-          expect { LoggregatorEmitter::Emitter.new("localhost:12345", "origin", 7) }.to raise_error(ArgumentError)
+          expect { LoggregatorEmitter::Emitter.new("localhost:#{@free_port}", "origin", 7) }.to raise_error(ArgumentError)
         end
 
         it "raises if source_type is not an integer or string" do
-          expect { LoggregatorEmitter::Emitter.new("localhost:12345", "origin", nil) }.to raise_error(ArgumentError)
-          expect { LoggregatorEmitter::Emitter.new("localhost:12345", "origin", 12.0) }.to raise_error(ArgumentError)
+          expect { LoggregatorEmitter::Emitter.new("localhost:#{@free_port}", "origin", nil) }.to raise_error(ArgumentError)
+          expect { LoggregatorEmitter::Emitter.new("localhost:#{@free_port}", "origin", 12.0) }.to raise_error(ArgumentError)
         end
 
         it "raises if source_type is too large of a string" do
-          expect { LoggregatorEmitter::Emitter.new("localhost:12345", "origin", "ABCD") }.to raise_error(ArgumentError)
+          expect { LoggregatorEmitter::Emitter.new("localhost:#{@free_port}", "origin", "ABCD") }.to raise_error(ArgumentError)
         end
 
         it "raises if source_type is too small of a string" do
-          expect { LoggregatorEmitter::Emitter.new("localhost:12345", "origin", "AB") }.to raise_error(ArgumentError)
+          expect { LoggregatorEmitter::Emitter.new("localhost:#{@free_port}", "origin", "AB") }.to raise_error(ArgumentError)
         end
       end
     end
   end
 
+  def test_tags(tags)
+    expected_tags = []
+    tags.each do |k, v|
+      expected_tags << ::Sonde::Envelope::TagsEntry.new(:key => k, :value => v)
+    end
+    expected_tags
+  end
 
+  let(:timestamp) {Time.now}
   describe "emit_log_envelope" do
     def make_emitter(host)
       LoggregatorEmitter::Emitter.new("#{host}:#{@free_port}", "origin", "API", 42)
     end
 
     it "successfully writes envelope protobuffers" do
+      tag = {"key1" => "value1"}
       emitter = make_emitter("0.0.0.0")
-      emitter.emit("my_app_id", "Hello there!")
+      Timecop.freeze timestamp do
+        emitter.emit("my_app_id", "Hello there!", tag)
+      end
 
       @server.wait_for_messages(1)
 
@@ -89,12 +105,32 @@ describe LoggregatorEmitter do
       expect(messages.length).to eq 1
       message = messages[0]
 
+      expect(message.time).to be_within(1).of timestamp
+      expect(message.logMessage.time).to be_within(1).of timestamp
       expect(message.logMessage.message).to eq "Hello there!"
       expect(message.logMessage.app_id).to eq "my_app_id"
       expect(message.logMessage.source_instance).to eq "42"
+      expect(message.tags).to eq test_tags(tag)
       expect(message.logMessage.message_type).to eq ::Sonde::LogMessage::MessageType::OUT
     end
 
+    it "successfully handles envelope with multiple tags" do
+      tags = {"key1" => "value1", "key2" => "value2"}
+      emitter = make_emitter("0.0.0.0")
+      Timecop.freeze timestamp do
+        emitter.emit("my_app_id", "Hello there!", tags)
+      end
+
+      @server.wait_for_messages(1)
+
+      messages = @server.messages
+
+      expect(messages.length).to eq 1
+      message = messages[0]
+
+      expect(message.tags).to eq test_tags(tags)
+    end
+
     it "gracefully handles failures to send messages" do
       emitter = make_emitter("0.0.0.0")
       UDPSocket.any_instance.stub(:sendmsg_nonblock).and_raise("Operation not permitted - sendmsg(2) (Errno::EPERM)")
@@ -118,6 +154,131 @@ describe LoggregatorEmitter do
     end
   end
 
+  describe "#emit_value_metric" do
+    let(:emitter) { LoggregatorEmitter::Emitter.new("0.0.0.0:#{@free_port}", "origin", "DEA")}
+
+    it 'successfully writes envelope protobuffers' do
+      tag = {"key1" => "value1"}
+      Timecop.freeze timestamp do
+        emitter.emit_value_metric('my-metric', 5155, 'my-units', tag)
+      end
+
+      @server.wait_for_messages(1)
+      messages = @server.messages
+
+      expect(messages.length).to eq 1
+      message = messages[0]
+
+      expect(message.time).to be_within(1).of(timestamp)
+      expect(message.valueMetric.value).to eq(5155)
+      expect(message.valueMetric.name).to eq('my-metric')
+      expect(message.valueMetric.unit).to eq('my-units')
+      expect(message.tags).to eq test_tags(tag)
+    end
+
+    it "successfully handles envelope with multiple tags" do
+      tags = {"key1" => "value1", "key2" => "value2"}
+      Timecop.freeze timestamp do
+        emitter.emit_value_metric('my-metric', 5155, 'my-units', tags)
+      end
+
+      @server.wait_for_messages(1)
+      messages = @server.messages
+
+      expect(messages.length).to eq 1
+      message = messages[0]
+
+      expect(message.tags).to eq test_tags(tags)
+    end
+  end
+
+  describe "#emit_counter" do
+    let(:emitter) { LoggregatorEmitter::Emitter.new("0.0.0.0:#{@free_port}", "origin", "DEA")}
+
+    it 'successfully writes envelope protobuffers' do
+      tag = {"key1" => "value1"}
+      Timecop.freeze timestamp do
+        emitter.emit_counter('my-counter', 5, tag)
+      end
+
+      @server.wait_for_messages(1)
+
+      messages = @server.messages
+
+      expect(messages.length).to eq 1
+      message = messages[0]
+
+      expect(message.time).to be_within(1).of(timestamp)
+      expect(message.counterEvent.delta).to eq(5)
+      expect(message.counterEvent.name).to eq('my-counter')
+      expect(message.tags).to eq test_tags(tag)
+    end
+
+    it "successfully handles envelope with multiple tags" do
+      tags = {"key1" => "value1", "key2" => "value2"}
+      Timecop.freeze timestamp do
+        emitter.emit_counter('my-counter', 5, tags)
+      end
+
+      @server.wait_for_messages(1)
+
+      messages = @server.messages
+
+      expect(messages.length).to eq 1
+      message = messages[0]
+
+      expect(message.tags).to eq test_tags(tags)
+    end
+  end
+
+  describe "#emit_container_metric" do
+    let(:emitter) { LoggregatorEmitter::Emitter.new("0.0.0.0:#{@free_port}", "origin", "DEA")}
+
+    it 'successfully writes envelope protobuffers' do
+      tag = {"key1" => "value1"}
+      Timecop.freeze timestamp do
+        emitter.emit_container_metric('app-id', 3, 1.3, 1024, 2048, tag)
+      end
+
+      @server.wait_for_messages(1)
+
+      messages = @server.messages
+
+      expect(messages.length).to eq 1
+      message = messages[0]
+
+      expect(message.time).to be_within(1).of(timestamp)
+      expect(message.containerMetric.applicationId).to eq('app-id')
+      expect(message.containerMetric.instanceIndex).to eq(3)
+      expect(message.containerMetric.cpuPercentage).to eq(1.3)
+      expect(message.containerMetric.memoryBytes).to eq(1024)
+      expect(message.containerMetric.diskBytes).to eq(2048)
+      expect(message.tags).to eq test_tags(tag)
+    end
+
+    it "successfully handles envelope with multiple tags" do
+      tags = {"key1" => "value1", "key2" => "value2"}
+      Timecop.freeze timestamp do
+        emitter.emit_container_metric('app-id', 3, 1.3, 1024, 2048, tags)
+      end
+
+      @server.wait_for_messages(1)
+
+      messages = @server.messages
+
+      expect(messages.length).to eq 1
+      message = messages[0]
+
+      expect(message.time).to be_within(1).of(timestamp)
+      expect(message.containerMetric.applicationId).to eq('app-id')
+      expect(message.containerMetric.instanceIndex).to eq(3)
+      expect(message.containerMetric.cpuPercentage).to eq(1.3)
+      expect(message.containerMetric.memoryBytes).to eq(1024)
+      expect(message.containerMetric.diskBytes).to eq(2048)
+      expect(message.tags).to eq test_tags(tags)
+    end
+  end
+
   {"emit" => LogMessage::MessageType::OUT, "emit_error" => LogMessage::MessageType::ERR}.each do |emit_method, message_type|
     describe "##{emit_method}" do
       def make_emitter(host)

data/spec/spec_helper.rb

@@ -1,4 +1,5 @@
 unless ENV['DISABLE_COVERAGE'] == 'true'
   require 'coveralls'
+  require 'timecop'
   Coveralls.wear!
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: loggregator_emitter
 version: !ruby/object:Gem::Version
-  version: 5.0.1
+  version: 5.1.1
 platform: ruby
 authors:
 - Pivotal
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-13 00:00:00.000000000 Z
+date: 2016-09-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: beefcake
@@ -38,6 +38,26 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.14
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.14
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -57,6 +77,9 @@ dependencies:
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+    - - ">="
       - !ruby/object:Gem::Version
         version: 2.14.1
   type: :development
@@ -64,10 +87,13 @@ dependencies:
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+    - - ">="
       - !ruby/object:Gem::Version
         version: 2.14.1
 - !ruby/object:Gem::Dependency
-  name: coveralls
+  name: timecop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -126,7 +152,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.9.3
+      version: 2.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -134,7 +160,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5.1
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Library to emit data to Loggregator