Module: NewRelic::Agent::Agent::InstanceMethods

Included in:
NewRelic::Agent::Agent
Defined in:
lib/new_relic/agent/agent.rb

Overview

Holds all the methods defined on NewRelic::Agent::Agent instances

API:

  • public

Instance Attribute Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#adaptive_sampler ⇒ Object (readonly)

API:

  • public



186
187
188
 
# File 'lib/new_relic/agent/agent.rb', line 186

def adaptive_sampler
  @adaptive_sampler
end

#adaptive_sampler_remote_parent_not_sampled ⇒ Object (readonly)

API:

  • public



188
189
190
 
# File 'lib/new_relic/agent/agent.rb', line 188

def adaptive_sampler_remote_parent_not_sampled
  @adaptive_sampler_remote_parent_not_sampled
end

#adaptive_sampler_remote_parent_sampled ⇒ Object (readonly)

API:

  • public



187
188
189
 
# File 'lib/new_relic/agent/agent.rb', line 187

def adaptive_sampler_remote_parent_sampled
  @adaptive_sampler_remote_parent_sampled
end

#attribute_filter ⇒ Object (readonly)

API:

  • public



185
186
187
 
# File 'lib/new_relic/agent/agent.rb', line 185

def attribute_filter
  @attribute_filter
end

#custom_event_aggregator ⇒ Object (readonly)

API:

  • public



181
182
183
 
# File 'lib/new_relic/agent/agent.rb', line 181

def custom_event_aggregator
  @custom_event_aggregator
end

#error_collector ⇒ Object (readonly)

error collector is a simple collection of recorded errors

API:

  • public



160
161
162
 
# File 'lib/new_relic/agent/agent.rb', line 160

def error_collector
  @error_collector
end

#events ⇒ Object (readonly)

Global events dispatcher. This will provides our primary mechanism for agent-wide events, such as finishing configuration, error notification and request before/after from Rack.

API:

  • public



170
171
172
 
# File 'lib/new_relic/agent/agent.rb', line 170

def events
  @events
end

#health_check ⇒ Object (readonly)

the agent control health check file generator

API:

  • public



153
154
155
 
# File 'lib/new_relic/agent/agent.rb', line 153

def health_check
  @health_check
end

#javascript_instrumentor ⇒ Object (readonly)

builder for JS agent scripts to inject

API:

  • public



164
165
166
 
# File 'lib/new_relic/agent/agent.rb', line 164

def javascript_instrumentor
  @javascript_instrumentor
end

#log_event_aggregator ⇒ Object (readonly)

API:

  • public



183
184
185
 
# File 'lib/new_relic/agent/agent.rb', line 183

def log_event_aggregator
  @log_event_aggregator
end

#monitors ⇒ Object (readonly)

listens and responds to events that need to process headers for synthetics and distributed tracing

API:

  • public



174
175
176
 
# File 'lib/new_relic/agent/agent.rb', line 174

def monitors
  @monitors
end

#monotonic_gc_profiler ⇒ Object (readonly)

GC::Profiler.total_time is not monotonic so we wrap it.

API:

  • public



180
181
182
 
# File 'lib/new_relic/agent/agent.rb', line 180

def monotonic_gc_profiler
  @monotonic_gc_profiler
end

#record_sql ⇒ Object (readonly)

whether we should record raw, obfuscated, or no sql

API:

  • public



162
163
164
 
# File 'lib/new_relic/agent/agent.rb', line 162

def record_sql
  @record_sql
end

#serverless_handler ⇒ Object (readonly)

API:

  • public



189
190
191
 
# File 'lib/new_relic/agent/agent.rb', line 189

def serverless_handler
  @serverless_handler
end

#service ⇒ Object (readonly)

service for communicating with collector

API:

  • public



166
167
168
 
# File 'lib/new_relic/agent/agent.rb', line 166

def service
  @service
end

#span_event_aggregator ⇒ Object (readonly)

API:

  • public



182
183
184
 
# File 'lib/new_relic/agent/agent.rb', line 182

def span_event_aggregator
  @span_event_aggregator
end

#sql_sampler ⇒ Object (readonly)

API:

  • public



158
159
160
 
# File 'lib/new_relic/agent/agent.rb', line 158

def sql_sampler
  @sql_sampler
end

#stats_engine ⇒ Object (readonly)

the statistics engine that holds all the timeslice data

API:

  • public



155
156
157
 
# File 'lib/new_relic/agent/agent.rb', line 155

def stats_engine
  @stats_engine
end

#transaction_event_recorder ⇒ Object (readonly)

API:

  • public



184
185
186
 
# File 'lib/new_relic/agent/agent.rb', line 184

def transaction_event_recorder
  @transaction_event_recorder
end

#transaction_rules ⇒ Object

Transaction and metric renaming rules as provided by the collector on connect. The former are applied during txns, the latter during harvest.

API:

  • public



178
179
180
 
# File 'lib/new_relic/agent/agent.rb', line 178

def transaction_rules
  @transaction_rules
end

#transaction_sampler ⇒ Object (readonly)

the transaction sampler that handles recording transactions

API:

  • public



157
158
159
 
# File 'lib/new_relic/agent/agent.rb', line 157

def transaction_sampler
  @transaction_sampler
end

Instance Method Details

#after_fork(options = {}) ⇒ Object

This method should be called in a forked process after a fork. It assumes the parent process initialized the agent, but does not assume the agent started.

The call is idempotent, but not reentrant.

  • It clears any metrics carried over from the parent process
  • Restarts the sampler thread if necessary
  • Initiates a new agent run and worker loop unless that was done in the parent process and :force_reconnect is not true

Options:

  • :force_reconnect => true to force the spawned process to establish a new connection, such as when forking a long running process. The default is false--it will only connect to the server if the parent had not connected.
  • :keep_retrying => false if we try to initiate a new connection, this tells me to only try it once so this method returns quickly if there is some kind of latency with the server.

API:

  • public



222
223
224
225
226
227
228
229
230
231
232
233
234
235
 
# File 'lib/new_relic/agent/agent.rb', line 222

def after_fork(options = {})
  return unless needs_after_fork_work?

  ::NewRelic::Agent.logger.debug("Starting the worker thread in #{Process.pid} (parent #{Process.ppid}) after forking.")
  @health_check.create_and_run_health_check_loop
  channel_id = options[:report_to_channel]
  install_pipe_service(channel_id) if channel_id

  # Clear out locks and stats left over from parent process
  reset_objects_with_locks
  drop_buffered_data

  setup_and_start_agent(options)
end

#agent_id=(agent_id) ⇒ Object

API:

  • public



199
200
201
 
# File 'lib/new_relic/agent/agent.rb', line 199

def agent_id=(agent_id)
  @service.agent_id = agent_id
end

#drop_buffered_data ⇒ Object

Clear out the metric data, errors, and transaction traces, etc.

API:

  • public



302
303
304
305
306
307
308
309
310
311
312
313
314
315
 
# File 'lib/new_relic/agent/agent.rb', line 302

def drop_buffered_data
  @stats_engine.reset!
  @error_collector.drop_buffered_data
  @transaction_sampler.reset!
  @transaction_event_recorder.drop_buffered_data
  @custom_event_aggregator.reset!
  @span_event_aggregator.reset!
  @log_event_aggregator.reset!
  @sql_sampler.reset!

  if Agent.config[:clear_transaction_state_after_fork]
    Tracer.clear_state
  end
end

#flush_pipe_data ⇒ Object

used only by resque

API:

  • public



324
325
326
327
328
 
# File 'lib/new_relic/agent/agent.rb', line 324

def flush_pipe_data # used only by resque
  if connected? && @service.is_a?(PipeService)
    transmit_data_types
  end
end

#install_pipe_service(channel_id) ⇒ Object

API:

  • public



252
253
254
255
256
257
258
259
260
261
 
# File 'lib/new_relic/agent/agent.rb', line 252

def install_pipe_service(channel_id)
  @service = PipeService.new(channel_id)
  if connected?
    @connected_pid = Process.pid
  else
    ::NewRelic::Agent.logger.debug("Child process #{Process.pid} not reporting to non-connected parent (process #{Process.ppid}).")
    @service.shutdown
    disconnect
  end
end

#merge_data_for_endpoint(endpoint, data) ⇒ Object

API:

  • public



351
352
353
354
355
356
357
358
359
360
361
362
 
# File 'lib/new_relic/agent/agent.rb', line 351

def merge_data_for_endpoint(endpoint, data)
  if data && !data.empty?
    container = container_for_endpoint(endpoint)
    if container.respond_to?(:has_metadata?) && container.has_metadata?
      container_for_endpoint(endpoint).merge!(data, false)
    else
      container_for_endpoint(endpoint).merge!(data)
    end
  end
rescue => e
  NewRelic::Agent.logger.error("Error while merging #{endpoint} data from child: ", e)
end

#needs_after_fork_work? ⇒ Boolean

Returns:

API:

  • public



237
238
239
240
241
242
243
244
245
246
247
248
249
250
 
# File 'lib/new_relic/agent/agent.rb', line 237

def needs_after_fork_work?
  needs_restart = false
  @after_fork_lock.synchronize do
    needs_restart = @harvester.needs_restart?
    @harvester.mark_started
  end

  return false if !needs_restart ||
    !Agent.config[:agent_enabled] ||
    !Agent.config[:monitor_mode] ||
    disconnected?

  true
end

#pop_trace_execution_flag ⇒ Object

Pop the current trace execution status. Restore trace execution status to what it was before we pushed the current flag.

API:

  • public



297
298
299
 
# File 'lib/new_relic/agent/agent.rb', line 297

def pop_trace_execution_flag # THREAD_LOCAL_ACCESS
  Tracer.state.pop_traced
end

#push_trace_execution_flag(should_trace = false) ⇒ Object

Push flag indicating whether we should be tracing in this thread. This uses a stack which allows us to disable tracing children of a transaction without affecting the tracing of the whole transaction

API:

  • public



291
292
293
 
# File 'lib/new_relic/agent/agent.rb', line 291

def push_trace_execution_flag(should_trace = false) # THREAD_LOCAL_ACCESS
  Tracer.state.push_traced(should_trace)
end

#reset_objects_with_locks ⇒ Object

Clear out state for any objects that we know lock from our parents This is necessary for cases where we're in a forked child and Ruby might be holding locks for background thread that aren't there anymore.

API:

  • public



320
321
322
 
# File 'lib/new_relic/agent/agent.rb', line 320

def reset_objects_with_locks
  @stats_engine = StatsEngine.new
end

#revert_to_default_configuration ⇒ Object

API:

  • public



263
264
265
266
 
# File 'lib/new_relic/agent/agent.rb', line 263

def revert_to_default_configuration
  Agent.config.remove_config_type(:manual)
  Agent.config.remove_config_type(:server)
end

#set_record_sql(should_record) ⇒ Object

Sets a thread local variable as to whether we should or should not record sql in the current thread. Returns the previous value, if there is one

API:

  • public



280
281
282
283
284
285
 
# File 'lib/new_relic/agent/agent.rb', line 280

def set_record_sql(should_record) # THREAD_LOCAL_ACCESS
  state = Tracer.state
  prev = state.record_sql
  state.record_sql = should_record
  prev.nil? || prev
end

#synthetics_event_aggregator ⇒ Object

API:

  • public



195
196
197
 
# File 'lib/new_relic/agent/agent.rb', line 195

def synthetics_event_aggregator
  @transaction_event_recorder.synthetics_event_aggregator
end

#transaction_event_aggregator ⇒ Object

API:

  • public



191
192
193
 
# File 'lib/new_relic/agent/agent.rb', line 191

def transaction_event_aggregator
  @transaction_event_recorder.transaction_event_aggregator
end

#trap_signals_for_litespeed ⇒ Object

API:

  • public



268
269
270
271
272
273
274
275
 
# File 'lib/new_relic/agent/agent.rb', line 268

def trap_signals_for_litespeed
  # if litespeed, then ignore all future SIGUSR1 - it's
  # litespeed trying to shut us down
  if Agent.config[:dispatcher] == :litespeed
    Signal.trap('SIGUSR1', 'IGNORE')
    Signal.trap('SIGTERM', 'IGNORE')
  end
end