Class: ScoutApm::LayerConverters::SlowJobConverter

Inherits:
ConverterBase
  • Object
show all
Defined in:
lib/scout_apm/layer_converters/slow_job_converter.rb

Instance Attribute Summary

Attributes inherited from ConverterBase

#request, #root_layer, #walker

Instance Method Summary collapse

Methods inherited from ConverterBase

#find_first_layer_of_type, #scope_layer

Constructor Details

#initialize ⇒ SlowJobConverter

Returns a new instance of SlowJobConverter.



4
5
6
7
8
9
10
11
12
13
14
 
# File 'lib/scout_apm/layer_converters/slow_job_converter.rb', line 4

def initialize(*)
  @backtraces = []
  super

  # After call to super, so @request is populated
  @points = if request.job?
              ScoutApm::Agent.instance.slow_job_policy.score(request)
            else
              -1
            end
end

Instance Method Details

#attach_backtraces(metric_hash) ⇒ Object 



142
143
144
145
146
147
 
# File 'lib/scout_apm/layer_converters/slow_job_converter.rb', line 142

def attach_backtraces(metric_hash)
  @backtraces.each do |meta_with_backtrace|
    metric_hash.keys.find { |k| k == meta_with_backtrace }.backtrace = meta_with_backtrace.backtrace
  end
  metric_hash
end

#call ⇒ Object 



24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
 
# File 'lib/scout_apm/layer_converters/slow_job_converter.rb', line 24

def call
  return nil unless request.job?
  return nil unless queue_layer
  return nil unless job_layer

  ScoutApm::Agent.instance.slow_job_policy.stored!(request)

  # record the change in memory usage
  mem_delta = ScoutApm::Instruments::Process::ProcessMemory.rss_to_mb(request.capture_mem_delta!)

  timing_metrics, allocation_metrics = create_metrics
  unless ScoutApm::Instruments::Allocations::ENABLED
    allocation_metrics = {}
  end

  SlowJobRecord.new(
    queue_layer.name,
    job_layer.name,
    root_layer.stop_time,
    job_layer.total_call_time,
    job_layer.total_exclusive_time,
    request.context,
    timing_metrics,
    allocation_metrics,
    mem_delta,
    job_layer.total_allocations,
    score)
end

#create_metrics ⇒ Object 



61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
 
# File 'lib/scout_apm/layer_converters/slow_job_converter.rb', line 61

def create_metrics
  metric_hash = Hash.new
  allocation_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|
    # Sometimes we start capturing a layer without knowing if we really
    # want to make an entry for it.  See ActiveRecord instrumentation for
    # an example. We start capturing before we know if a query is cached
    # or not, and want to skip any cached queries.
    next if layer.annotations[:ignorable]

    # The queue_layer is useful to capture for other reasons, but doesn't
    # create a MetricMeta/Stat of its own
    next if layer == queue_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 == job_layer # We don't scope the controller under itself
                     {}
                   else
                     {:scope => job_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!(layer.annotations)

    if layer.backtrace
      bt = ScoutApm::Utils::BacktraceParser.new(layer.backtrace).call
      if bt.any? # we could walk thru the call stack and not find in-app code
        meta.backtrace = bt
        # Why not just call meta.backtrace and call it done? The walker could access a later later that generates the same MetricMeta but doesn't have a backtrace. This could be
        # lost in the metric_hash if it is replaced by the new key.
        @backtraces << meta
      else
        ScoutApm::Agent.instance.logger.debug { "Unable to capture an app-specific backtrace for #{meta.inspect}\n#{layer.backtrace}" }
      end
    end

    metric_hash[meta] ||= MetricStats.new( meta_options.has_key?(:scope) )
    allocation_metric_hash[meta] ||= MetricStats.new( meta_options.has_key?(:scope) )
    stat = metric_hash[meta]
    stat.update!(layer.total_call_time, layer.total_exclusive_time)
    stat = allocation_metric_hash[meta]
    stat.update!(layer.total_allocations, layer.total_exclusive_allocations)

    # Merged Metric (no specifics, just sum up by type)
    meta = MetricMeta.new("#{layer.type}/all")
    metric_hash[meta] ||= MetricStats.new(false)
    allocation_metric_hash[meta] ||= MetricStats.new(false)
    stat = metric_hash[meta]
    stat.update!(layer.total_call_time, layer.total_exclusive_time)
    stat = allocation_metric_hash[meta]
    stat.update!(layer.total_allocations, layer.total_exclusive_allocations)
  end

  metric_hash = attach_backtraces(metric_hash)
  allocation_metric_hash = attach_backtraces(allocation_metric_hash)

  [metric_hash,allocation_metric_hash]
end

#job_layer ⇒ Object 



57
58
59
 
# File 'lib/scout_apm/layer_converters/slow_job_converter.rb', line 57

def job_layer
  @job_layer ||= find_first_layer_of_type("Job")
end

#name ⇒ Object 



16
17
18
 
# File 'lib/scout_apm/layer_converters/slow_job_converter.rb', line 16

def name
  request.unique_name
end

#queue_layer ⇒ Object 



53
54
55
 
# File 'lib/scout_apm/layer_converters/slow_job_converter.rb', line 53

def queue_layer
  @queue_layer ||= find_first_layer_of_type("Queue")
end

#score ⇒ Object 



20
21
22
 
# File 'lib/scout_apm/layer_converters/slow_job_converter.rb', line 20

def score
  @points
end