scout_apm 1.4.6 → 1.5.0.pre

data/test/unit/histogram_test.rb

@@ -0,0 +1,93 @@
+require 'test_helper'
+
+require 'scout_apm/histogram'
+
+# These tests assume insertion order.  Because of the approximate nature of
+# this data structure, changing the order can slightly change the results,
+# causing these tests to fail.  The overall "shape" of the histogram should be
+# approximately the same in the case of alternate orders, but I'm punting on
+# any attempts to automate that.
+class HistogramTest < Minitest::Test
+  # When we have enough slots, we don't have any fuzz in the data, so exact numbers.
+  def test_histogram_min_and_max_with_big_enough_histogram
+    hist = ScoutApm::NumericHistogram.new(10)
+
+    10.times {
+      (1..10).to_a.each do |i|
+        hist.add(i)
+      end
+    }
+
+    assert_equal 1, hist.quantile(0)
+    assert_equal 10, hist.quantile(100)
+  end
+
+  # When we don't have enough slots, we have to approximate the buckets
+  # In this case, the true range is 1 through 10, and we only have 5 buckets to allocate.
+  # 1 2 3 4 5 6 7 8 9 10 # <-- True Range
+  #   x   x   x   x   x  # <-- Where buckets get adjusted to
+  def test_histogram_min_and_max_with_fewer_buckets
+    hist = ScoutApm::NumericHistogram.new(5)
+
+    10.times {
+      (1..10).to_a.each do |i|
+        hist.add(i)
+      end
+    }
+
+    assert_equal 1.5, hist.quantile(0).round(1)
+    assert_equal 9.5, hist.quantile(100).round(1)
+  end
+
+  def test_combine
+    hist1 = ScoutApm::NumericHistogram.new(5)
+    10.times {
+      (1..10).to_a.each do |i|
+        hist1.add(i)
+      end
+    }
+
+    hist2 = ScoutApm::NumericHistogram.new(10)
+    10.times {
+      (1..10).to_a.each do |i|
+        hist2.add(i)
+      end
+    }
+
+    combined = hist1.combine!(hist2)
+    assert_equal 1.5, combined.quantile(0).round(1)
+    assert_equal 9.5, combined.quantile(100).round(1)
+    assert_equal 200, combined.total
+  end
+
+  def test_combine_retains_order
+    hist1 = ScoutApm::NumericHistogram.new(5)
+    10.times {
+      (10..50).to_a.each do |i|
+        hist1.add(i)
+      end
+    }
+
+    hist2 = ScoutApm::NumericHistogram.new(10)
+    10.times {
+      (1..10).to_a.each do |i|
+        hist2.add(i)
+      end
+    }
+
+    combined = hist1.combine!(hist2)
+    assert combined.quantile(0) < combined.quantile(100)
+  end
+
+  def test_mean
+    hist = ScoutApm::NumericHistogram.new(5)
+    10.times {
+      (1..10).to_a.each do |i|
+        hist.add(i)
+      end
+    }
+
+    assert_equal 5.5, hist.mean
+  end
+end
+

data/test/unit/serializers/payload_serializer_test.rb

@@ -33,7 +33,7 @@ class PayloadSerializerTest < Minitest::Test
       :unique_id => "unique_idz",
       :agent_version => 123
     }
-    payload = ScoutApm::Serializers::PayloadSerializerToJson.serialize(metadata, {}, {})
+    payload = ScoutApm::Serializers::PayloadSerializerToJson.serialize(metadata, {}, {}, [], [])
 
     # symbol keys turn to strings
     formatted_metadata = {
@@ -74,7 +74,7 @@ class PayloadSerializerTest < Minitest::Test
         stats.total_exclusive_time = 0.07813208899999999
       }
     }
-    payload = ScoutApm::Serializers::PayloadSerializerToJson.serialize({}, metrics, {})
+    payload = ScoutApm::Serializers::PayloadSerializerToJson.serialize({}, metrics, {}, [], [])
     formatted_metrics = [
       {
         "key" => {
@@ -145,8 +145,8 @@ class PayloadSerializerTest < Minitest::Test
     context = ScoutApm::Context.new
     context.add({"this" => "that"})
     context.add_user({"hello" => "goodbye"})
-    slow_t = ScoutApm::SlowTransaction.new("http://example.com/blabla", "Buckethead/something/else", 1.23, slow_transaction_metrics, context, Time.at(1448198788), [])
-    payload = ScoutApm::Serializers::PayloadSerializerToJson.serialize({}, {}, [slow_t])
+    slow_t = ScoutApm::SlowTransaction.new("http://example.com/blabla", "Buckethead/something/else", 1.23, slow_transaction_metrics, context, Time.at(1448198788), StackProf.new)
+    payload = ScoutApm::Serializers::PayloadSerializerToJson.serialize({}, {}, [slow_t], [], [])
     formatted_slow_transactions = [
       {
         "key" => {
@@ -204,7 +204,7 @@ class PayloadSerializerTest < Minitest::Test
       :quotie => "here are some \"quotes\"",
       :payload_version => 2,
     }
-    payload = ScoutApm::Serializers::PayloadSerializerToJson.serialize(metadata, {}, {})
+    payload = ScoutApm::Serializers::PayloadSerializerToJson.serialize(metadata, {}, {}, [], [])
 
     # symbol keys turn to strings
     formatted_metadata = {

data/test/unit/{slow_transaction_set_test.rb → slow_item_set_test.rb}

@@ -1,17 +1,17 @@
 require 'test_helper'
 
-require 'scout_apm/slow_transaction_set'
+require 'scout_apm/slow_item_set'
 require 'scout_apm/slow_transaction'
 
-class SlowTransactionSetTest < Minitest::Test
+class SlowItemSetTest < Minitest::Test
   def test_adding_to_empty_set
-    set = ScoutApm::SlowTransactionSet.new(3, 1)
+    set = ScoutApm::SlowItemSet.new(3, 1)
     set << make_slow("Controller/Foo")
     assert_equal 1, set.count
   end
 
   def test_adding_to_partially_full_set
-    set = ScoutApm::SlowTransactionSet.new(3, 1)
+    set = ScoutApm::SlowItemSet.new(3, 1)
     set << make_slow("Controller/Foo")
     set << make_slow("Controller/Foo")
     assert_equal 2, set.count
@@ -19,7 +19,7 @@ class SlowTransactionSetTest < Minitest::Test
 
   def test_overflow_of_one_type
     max_size = 3
-    set = ScoutApm::SlowTransactionSet.new(max_size, 1)
+    set = ScoutApm::SlowItemSet.new(max_size, 1)
     set << make_slow("Controller/Foo")
     set << make_slow("Controller/Foo")
     set << make_slow("Controller/Foo")
@@ -31,7 +31,7 @@ class SlowTransactionSetTest < Minitest::Test
 
   def test_eviction_of_overrepresented
     max_size = 3
-    set = ScoutApm::SlowTransactionSet.new(max_size, 1)
+    set = ScoutApm::SlowItemSet.new(max_size, 1)
     set << make_slow("Controller/Foo")
     set << make_slow("Controller/Foo")
     set << make_slow("Controller/Foo")
@@ -49,7 +49,7 @@ class SlowTransactionSetTest < Minitest::Test
   # evicted one was the fastest of the Foos
   def test_eviction_of_fastest
     max_size = 3
-    set = ScoutApm::SlowTransactionSet.new(max_size, 1)
+    set = ScoutApm::SlowItemSet.new(max_size, 1)
 
     [1,2,3].shuffle.each do |seconds| # Shuffle to remove any assumptions on order
       set << make_slow("Controller/Foo", seconds)
@@ -63,7 +63,7 @@ class SlowTransactionSetTest < Minitest::Test
   def test_eviction_when_no_overrepresented
     max_size = 4
     fair = 2
-    set = ScoutApm::SlowTransactionSet.new(max_size, fair)
+    set = ScoutApm::SlowItemSet.new(max_size, fair)
 
     # Full, but each is at fair level
     set << make_slow("Controller/Bar")

data/test/unit/slow_job_policy_test.rb

@@ -0,0 +1,55 @@
+require 'test_helper'
+
+require 'scout_apm/slow_job_policy'
+
+class SlowJobPolicyTest < Minitest::Test
+  def test_first_call_is_not_slow
+    policy = ScoutApm::SlowJobPolicy.new
+    assert !policy.slow?("TestWorker", 10)
+  end
+
+  # All of these get faster and faster, so none are marked as slow.
+  def test_fast_calls_are_not_slow
+    policy = ScoutApm::SlowJobPolicy.new
+    assert !policy.slow?("TestWorker", 10)
+    assert !policy.slow?("TestWorker", 8)
+    assert !policy.slow?("TestWorker", 6)
+    assert !policy.slow?("TestWorker", 4)
+    assert !policy.slow?("TestWorker", 2)
+  end
+
+  def test_slow_calls_are_marked_as_slow
+    policy = ScoutApm::SlowJobPolicy.new
+    policy.slow?("TestWorker", 10) # Prime it with a not-slow
+
+    assert policy.slow?("TestWorker", 12)
+    assert policy.slow?("TestWorker", 14)
+    assert policy.slow?("TestWorker", 16)
+    assert policy.slow?("TestWorker", 18)
+  end
+
+  def test_mix_of_fast_and_slow
+    policy = ScoutApm::SlowJobPolicy.new
+    policy.slow?("TestWorker", 10) # Prime it with a not-slow
+
+    assert  policy.slow?("TestWorker", 12)
+    assert !policy.slow?("TestWorker", 8)
+    assert  policy.slow?("TestWorker", 13)
+    assert !policy.slow?("TestWorker", 6)
+  end
+
+  def test_different_workers_dont_interfere
+    policy = ScoutApm::SlowJobPolicy.new
+    policy.slow?("TestWorker", 10) # Prime it with a not-slow
+    policy.slow?("OtherWorker", 1.0) # Prime it with a not-slow
+
+    assert !policy.slow?("TestWorker", 8)
+    assert  policy.slow?("OtherWorker", 2)
+    assert !policy.slow?("TestWorker", 1)
+    assert  policy.slow?("OtherWorker", 3)
+    assert  policy.slow?("TestWorker", 12)
+    assert !policy.slow?("OtherWorker", 1)
+    assert  policy.slow?("TestWorker", 12)
+    assert  policy.slow?("OtherWorker", 4)
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: scout_apm
 version: !ruby/object:Gem::Version
-  version: 1.4.6
+  version: 1.5.0.pre
 platform: ruby
 authors:
 - Derek Haynes
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-04 00:00:00.000000000 Z
+date: 2016-04-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -76,6 +76,7 @@ files:
 - lib/scout_apm/background_job_integrations/sidekiq.rb
 - lib/scout_apm/background_worker.rb
 - lib/scout_apm/bucket_name_splitter.rb
+- lib/scout_apm/call_set.rb
 - lib/scout_apm/capacity.rb
 - lib/scout_apm/config.rb
 - lib/scout_apm/context.rb
@@ -88,6 +89,8 @@ files:
 - lib/scout_apm/framework_integrations/rails_3_or_4.rb
 - lib/scout_apm/framework_integrations/ruby.rb
 - lib/scout_apm/framework_integrations/sinatra.rb
+- lib/scout_apm/histogram.rb
+- lib/scout_apm/instruments/.DS_Store
 - lib/scout_apm/instruments/action_controller_rails_2.rb
 - lib/scout_apm/instruments/action_controller_rails_3_rails4.rb
 - lib/scout_apm/instruments/active_record.rb
@@ -105,11 +108,20 @@ files:
 - lib/scout_apm/instruments/rails_router.rb
 - lib/scout_apm/instruments/redis.rb
 - lib/scout_apm/instruments/sinatra.rb
+- lib/scout_apm/job_record.rb
 - lib/scout_apm/layaway.rb
 - lib/scout_apm/layaway_file.rb
 - lib/scout_apm/layer.rb
-- lib/scout_apm/layer_converter.rb
+- lib/scout_apm/layer_converters/converter_base.rb
+- lib/scout_apm/layer_converters/depth_first_walker.rb
+- lib/scout_apm/layer_converters/error_converter.rb
+- lib/scout_apm/layer_converters/job_converter.rb
+- lib/scout_apm/layer_converters/metric_converter.rb
+- lib/scout_apm/layer_converters/request_queue_time_converter.rb
+- lib/scout_apm/layer_converters/slow_job_converter.rb
+- lib/scout_apm/layer_converters/slow_request_converter.rb
 - lib/scout_apm/metric_meta.rb
+- lib/scout_apm/metric_set.rb
 - lib/scout_apm/metric_stats.rb
 - lib/scout_apm/middleware.rb
 - lib/scout_apm/platform_integrations/cloud_foundry.rb
@@ -117,12 +129,14 @@ files:
 - lib/scout_apm/platform_integrations/server.rb
 - lib/scout_apm/reporter.rb
 - lib/scout_apm/request_manager.rb
-- lib/scout_apm/request_queue_time.rb
 - lib/scout_apm/serializers/app_server_load_serializer.rb
 - lib/scout_apm/serializers/deploy_serializer.rb
 - lib/scout_apm/serializers/directive_serializer.rb
+- lib/scout_apm/serializers/jobs_serializer_to_json.rb
+- lib/scout_apm/serializers/metrics_to_json_serializer.rb
 - lib/scout_apm/serializers/payload_serializer.rb
 - lib/scout_apm/serializers/payload_serializer_to_json.rb
+- lib/scout_apm/serializers/slow_jobs_serializer_to_json.rb
 - lib/scout_apm/server_integrations/null.rb
 - lib/scout_apm/server_integrations/passenger.rb
 - lib/scout_apm/server_integrations/puma.rb
@@ -130,15 +144,18 @@ files:
 - lib/scout_apm/server_integrations/thin.rb
 - lib/scout_apm/server_integrations/unicorn.rb
 - lib/scout_apm/server_integrations/webrick.rb
+- lib/scout_apm/slow_item_set.rb
+- lib/scout_apm/slow_job_policy.rb
+- lib/scout_apm/slow_job_record.rb
 - lib/scout_apm/slow_request_policy.rb
 - lib/scout_apm/slow_transaction.rb
-- lib/scout_apm/slow_transaction_set.rb
 - lib/scout_apm/stack_item.rb
 - lib/scout_apm/stackprof_tree_collapser.rb
 - lib/scout_apm/store.rb
 - lib/scout_apm/tracer.rb
 - lib/scout_apm/tracked_request.rb
 - lib/scout_apm/utils/active_record_metric_name.rb
+- lib/scout_apm/utils/backtrace_parser.rb
 - lib/scout_apm/utils/fake_stack_prof.rb
 - lib/scout_apm/utils/installed_gems.rb
 - lib/scout_apm/utils/null_logger.rb
@@ -154,10 +171,12 @@ files:
 - test/unit/agent_test.rb
 - test/unit/config_test.rb
 - test/unit/environment_test.rb
+- test/unit/histogram_test.rb
 - test/unit/instruments/active_record_instruments_test.rb
 - test/unit/layaway_test.rb
 - test/unit/serializers/payload_serializer_test.rb
-- test/unit/slow_transaction_set_test.rb
+- test/unit/slow_item_set_test.rb
+- test/unit/slow_job_policy_test.rb
 - test/unit/sql_sanitizer_test.rb
 - test/unit/utils/active_record_metric_name_test.rb
 homepage: https://github.com/scoutapp/scout_apm_ruby
@@ -175,9 +194,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: scout_apm
 rubygems_version: 2.6.2
@@ -190,10 +209,12 @@ test_files:
 - test/unit/agent_test.rb
 - test/unit/config_test.rb
 - test/unit/environment_test.rb
+- test/unit/histogram_test.rb
 - test/unit/instruments/active_record_instruments_test.rb
 - test/unit/layaway_test.rb
 - test/unit/serializers/payload_serializer_test.rb
-- test/unit/slow_transaction_set_test.rb
+- test/unit/slow_item_set_test.rb
+- test/unit/slow_job_policy_test.rb
 - test/unit/sql_sanitizer_test.rb
 - test/unit/utils/active_record_metric_name_test.rb
 has_rdoc: 

data/lib/scout_apm/layer_converter.rb

@@ -1,222 +0,0 @@
-module ScoutApm
-  class LayerConverterBase
-    attr_reader :walker
-    attr_reader :request
-    attr_reader :root_layer
-
-    def initialize(request)
-      @request = request
-      @root_layer = request.root_layer
-      @walker = LayerDepthFirstWalker.new(root_layer)
-    end
-
-    # Scope is determined by the first Controller we hit.  Most of the time
-    # there will only be 1 anyway.  But if you have a controller that calls
-    # another controller method, we may pick that up:
-    #     def update
-    #       show
-    #       render :update
-    #     end
-    def scope_layer
-      @scope_layer ||= walker.walk do |layer|
-        if layer.type == "Controller"
-          break layer
-        end
-      end
-    end
-  end
-
-  # Take a TrackedRequest and turn it into a hash of:
-  #   MetricMeta => MetricStats
-  # This will do some merging of metrics as duplicate calls are seen.
-  class LayerMetricConverter < LayerConverterBase
-    def call
-      scope = scope_layer
-
-      # TODO: Track requests that never reach a Controller (for example, when
-      # Middleware decides to return rather than passing onward)
-      return {} unless scope
-
-      create_metrics
-    end
-
-    # Full metrics from this request. These get aggregated in Store for the
-    # overview metrics, or stored permanently in a SlowTransaction
-    # Some merging of metrics will happen here, so if a request calls the same
-    # ActiveRecord or View repeatedly, it'll get merged.
-    def create_metrics
-      metric_hash = Hash.new
-
-      walker.walk do |layer|
-        meta_options = if layer == scope_layer # We don't scope the controller under itself
-                         {}
-                       else
-                         {:scope => scope_layer.legacy_metric_name}
-                       end
-
-        # we don't need to use the full metric name for scoped metrics as we only display metrics aggregrated
-        # by type.
-        metric_name = meta_options.has_key?(:scope) ? layer.type : layer.legacy_metric_name
-
-        meta = MetricMeta.new(metric_name, meta_options)
-        metric_hash[meta] ||= MetricStats.new( meta_options.has_key?(:scope) )
-
-        stat = metric_hash[meta]
-        stat.update!(layer.total_call_time, layer.total_exclusive_time)
-      end
-      metric_hash
-    end
-  end
-
-  class LayerErrorConverter < LayerConverterBase
-    def call
-      scope = scope_layer
-
-      # Should we mark a request as errored out if a middleware raises?
-      # How does that interact w/ a tool like Sentry or Honeybadger?
-      return {} unless scope
-      return {} unless request.error?
-
-      meta = MetricMeta.new("Errors/#{scope.legacy_metric_name}", {})
-      stat = MetricStats.new
-      stat.update!(1)
-
-      { meta => stat }
-    end
-  end
-
-  # Take a TrackedRequest and turn it into a slow transaction if needed
-  # return a 2 element array, [ Slow Transaction or Nil ,  Hash of metrics to store ]
-  class LayerSlowTransactionConverter < LayerConverterBase
-    def call
-      scope = scope_layer
-      return [nil, {}] unless scope
-
-      policy = ScoutApm::Agent.instance.slow_request_policy.capture_type(root_layer.total_call_time)
-      if policy == ScoutApm::SlowRequestPolicy::CAPTURE_NONE
-        return [nil, {}] 
-      end
-
-      # increment the slow transaction count if this is a slow transaction.
-      meta = MetricMeta.new("SlowTransaction/#{scope.legacy_metric_name}")
-      stat = MetricStats.new
-      stat.update!(1)
-
-      uri = request.annotations[:uri] || ""
-
-      metrics = create_metrics
-      # Disable stackprof output for now
-      stackprof = [] # request.stackprof
-
-      [
-        SlowTransaction.new(uri,
-                            scope.legacy_metric_name,
-                            root_layer.total_call_time,
-                            metrics,
-                            request.context,
-                            root_layer.stop_time,
-                            stackprof),
-        { meta => stat }
-      ]
-
-    end
-
-    # Full metrics from this request. These get aggregated in Store for the
-    # overview metrics, or stored permanently in a SlowTransaction
-    # Some merging of metrics will happen here, so if a request calls the same
-    # ActiveRecord or View repeatedly, it'll get merged.
-    def create_metrics
-      metric_hash = Hash.new
-
-      # Keep a list of subscopes, but only ever use the front one.  The rest
-      # get pushed/popped in cases when we have many levels of subscopable
-      # layers.  This lets us push/pop without otherwise keeping track very closely.
-      subscope_layers = []
-
-      walker.before do |layer|
-        if layer.subscopable?
-          subscope_layers.push(layer)
-        end
-      end
-
-      walker.after do |layer|
-        if layer.subscopable?
-          subscope_layers.pop
-        end
-      end
-
-      walker.walk do |layer|
-        meta_options = if subscope_layers.first && layer != subscope_layers.first # Don't scope under ourself.
-                         subscope_name = subscope_layers.first.legacy_metric_name
-                         {:scope => subscope_name}
-                       elsif layer == scope_layer # We don't scope the controller under itself
-                         {}
-                       else
-                         {:scope => scope_layer.legacy_metric_name}
-                       end
-
-        # Specific Metric
-        meta_options.merge!(:desc => layer.desc.to_s) if layer.desc
-        meta = MetricMeta.new(layer.legacy_metric_name, meta_options)
-        meta.extra.merge!(:backtrace => ScoutApm::SlowTransaction.backtrace_parser(layer.backtrace)) if layer.backtrace
-        metric_hash[meta] ||= MetricStats.new( meta_options.has_key?(:scope) )
-        stat = metric_hash[meta]
-        stat.update!(layer.total_call_time, layer.total_exclusive_time)
-
-        # Merged Metric (no specifics, just sum up by type)
-        meta = MetricMeta.new("#{layer.type}/all")
-        metric_hash[meta] ||= MetricStats.new(false)
-        stat = metric_hash[meta]
-        stat.update!(layer.total_call_time, layer.total_exclusive_time)
-      end
-
-      metric_hash
-    end
-  end
-
-  class LayerDepthFirstWalker
-    attr_reader :root_layer
-
-    def initialize(root_layer)
-      @root_layer = root_layer
-    end
-
-    def before(&block)
-      @before_block = block
-    end
-
-    def after(&block)
-      @after_block = block
-    end
-
-    def walk(layer=root_layer, &block)
-      # Need to run this for the root layer the first time through.
-      if layer == root_layer
-        @before_block.call(layer) if @before_block
-        yield layer
-        @after_block.call(layer) if @after_block
-      end
-
-      layer.children.each do |child|
-        @before_block.call(child) if @before_block
-        yield child
-        walk(child, &block)
-        @after_block.call(child) if @after_block
-      end
-      nil
-    end
-
-    # Do this w/o using recursion, since it's prone to stack overflows
-    # Takes a block to run over each layer
-    # def walk
-      # layer_stack = [root_layer]
-
-      # while layer_stack.any?
-        # current_layer = layer_stack.pop
-        # current_layer.children.reverse.each { |child| layer_stack.push(child) }
-
-        # yield current_layer
-      # end
-    # end
-  end
-end

data/lib/scout_apm/request_queue_time.rb

@@ -1,57 +0,0 @@
-module ScoutApm
-  class RequestQueueTime < LayerConverterBase
-    HEADERS = %w(X-Queue-Start X-Request-Start X-QUEUE-START X-REQUEST-START x-queue-start x-request-start)
-
-    # Headers is a hash of request headers.  In Rails, request.headers would be appropriate
-    def initialize(request)
-      super(request)
-      @headers = request.headers
-    end
-
-    def call
-      return {} unless headers
-
-      raw_start = locate_timestamp
-      return {} unless raw_start
-
-      parsed_start = parse(raw_start)
-      return {} unless parsed_start
-
-      request_start = root_layer.start_time
-      queue_time = (request_start - parsed_start).to_f
-
-      # If we end up with a negative value, just bail out and don't report anything
-      return {} if queue_time < 0
-
-      meta = MetricMeta.new("QueueTime/Request", {:scope => scope_layer.legacy_metric_name})
-      stat = MetricStats.new(true)
-      stat.update!(queue_time)
-
-      { meta => stat }
-    end
-
-    private
-
-    attr_reader :headers
-
-    # Looks through the possible headers with this data, and extracts the raw
-    # value of the header
-    # Returns nil if not found
-    def locate_timestamp
-      return nil unless headers
-
-      header = HEADERS.find { |candidate| headers[candidate] }
-      if header
-        data = headers[header]
-        data.to_s.gsub(/(t=|\.)/, '')
-      else
-        nil
-      end
-    end
-
-    # Returns a timestamp in fractional seconds since epoch
-    def parse(time_string)
-      Time.at("#{time_string[0,10]}.#{time_string[10,13]}".to_f)
-    end
-  end
-end