Class: NewRelic::Agent::LogEventAggregator

Inherits:
EventAggregator show all
Defined in:
lib/new_relic/agent/log_event_aggregator.rb

Constant Summary collapse

LEVEL_KEY =

Per-message keys

'level'.freeze
MESSAGE_KEY = 
'message'.freeze
TIMESTAMP_KEY = 
'timestamp'.freeze
PRIORITY_KEY = 
'priority'.freeze
LINES =

Metric keys

'Logging/lines'.freeze
DROPPED_METRIC = 
'Logging/Forwarding/Dropped'.freeze
SEEN_METRIC = 
'Supportability/Logging/Forwarding/Seen'.freeze
SENT_METRIC = 
'Supportability/Logging/Forwarding/Sent'.freeze
LOGGER_SUPPORTABILITY_FORMAT = 
'Supportability/Logging/Ruby/Logger/%s'.freeze
LOGSTASHER_SUPPORTABILITY_FORMAT = 
'Supportability/Logging/Ruby/LogStasher/%s'.freeze
METRICS_SUPPORTABILITY_FORMAT = 
'Supportability/Logging/Metrics/Ruby/%s'.freeze
FORWARDING_SUPPORTABILITY_FORMAT = 
'Supportability/Logging/Forwarding/Ruby/%s'.freeze
DECORATING_SUPPORTABILITY_FORMAT = 
'Supportability/Logging/LocalDecorating/Ruby/%s'.freeze
LABELS_SUPPORTABILITY_FORMAT = 
'Supportability/Logging/Labels/Ruby/%s'.freeze
MAX_BYTES =

32 * 1024 bytes (32 kibibytes)

32768
OVERALL_ENABLED_KEY =

Config keys

:'application_logging.enabled'
METRICS_ENABLED_KEY = 
:'application_logging.metrics.enabled'
FORWARDING_ENABLED_KEY = 
:'application_logging.forwarding.enabled'
DECORATING_ENABLED_KEY = 
:'application_logging.local_decorating.enabled'
LABELS_ENABLED_KEY = 
:'application_logging.forwarding.labels.enabled'
LOG_LEVEL_KEY = 
:'application_logging.forwarding.log_level'
CUSTOM_ATTRIBUTES_KEY = 
:'application_logging.forwarding.custom_attributes'

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from EventAggregator

#after_initialize, buffer_class, capacity_key, #enabled?, enabled_fn, enabled_keys, #has_metadata?, #merge!, named

Constructor Details

#initialize(events) ⇒ LogEventAggregator

Returns a new instance of LogEventAggregator.



48
49
50
51
52
53
54
55
56
57
58
 
# File 'lib/new_relic/agent/log_event_aggregator.rb', line 48

def initialize(events)
  super(events)
  @counter_lock = Mutex.new
  @seen = 0
  @seen_by_severity = Hash.new(0)
  @high_security = NewRelic::Agent.config[:high_security]
  @instrumentation_logger_enabled = NewRelic::Agent::Instrumentation::Logger.enabled?
  @attributes = NewRelic::Agent::LogEventAttributes.new

  register_for_done_configuring(events)
end

Instance Attribute Details

#attributes ⇒ Object (readonly)

Returns the value of attribute attributes.



46
47
48
 
# File 'lib/new_relic/agent/log_event_aggregator.rb', line 46

def attributes
  @attributes
end

Class Method Details

.payload_to_melt_format(data) ⇒ Object

Because our transmission format (MELT) is different than historical agent payloads, extract the munging here to keep the service focused on the general harvest + transmit instead of the format.

Payload shape matches the publicly documented MELT format. docs.newrelic.com/docs/logs/log-api/introduction-log-api

We have to keep the aggregated payloads in a separate shape, though, to work with the priority sampling buffers



205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
 
# File 'lib/new_relic/agent/log_event_aggregator.rb', line 205

def self.payload_to_melt_format(data)
  common_attributes = LinkingMetadata.append_service_linking_metadata({})

  # To save on unnecessary data transmission, trim the entity.type
  # sent by classic logs-in-context
  common_attributes.delete(ENTITY_TYPE_KEY)
  aggregator = NewRelic::Agent.agent.log_event_aggregator
  common_attributes.merge!(aggregator.attributes.custom_attributes)
  common_attributes.merge!(aggregator.labels)

  _, items = data
  payload = [{
    common: {attributes: common_attributes},
    logs: items.map(&:last)
  }]

  return [payload, items.size]
end

Instance Method Details

#add_custom_attributes(custom_attributes) ⇒ Object 



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

def add_custom_attributes(custom_attributes)
  attributes.add_custom_attributes(custom_attributes)
end

#add_event_metadata(formatted_message, severity) ⇒ Object 



144
145
146
147
148
149
150
151
152
 
# File 'lib/new_relic/agent/log_event_aggregator.rb', line 144

def add_event_metadata(formatted_message, severity)
  metadata = {
    LEVEL_KEY => severity,
    TIMESTAMP_KEY => Process.clock_gettime(Process::CLOCK_REALTIME) * 1000
  }
  metadata[MESSAGE_KEY] = formatted_message unless formatted_message.nil?

  LinkingMetadata.append_trace_linking_metadata(metadata)
end

#add_logstasher_event_attributes(event, log) ⇒ Object 



178
179
180
181
182
183
184
185
186
 
# File 'lib/new_relic/agent/log_event_aggregator.rb', line 178

def add_logstasher_event_attributes(event, log)
  log_copy = log.dup
  # Delete previously reported attributes
  log_copy.delete('message')
  log_copy.delete('level')
  log_copy.delete('@timestamp')

  event['attributes'] = log_copy
end

#capacity ⇒ Object 



60
61
62
 
# File 'lib/new_relic/agent/log_event_aggregator.rb', line 60

def capacity
  @buffer.capacity
end

#create_event(priority, formatted_message, severity) ⇒ Object 



163
164
165
166
167
168
 
# File 'lib/new_relic/agent/log_event_aggregator.rb', line 163

def create_event(priority, formatted_message, severity)
  formatted_message = truncate_message(formatted_message)
  event = add_event_metadata(formatted_message, severity)

  create_prioritized_event(priority, event)
end

#create_logstasher_event(priority, severity, log) ⇒ Object 



170
171
172
173
174
175
176
 
# File 'lib/new_relic/agent/log_event_aggregator.rb', line 170

def create_logstasher_event(priority, severity, log)
  formatted_message = log['message'] ? truncate_message(log['message']) : nil
  event = add_event_metadata(formatted_message, severity)
  add_logstasher_event_attributes(event, log)

  create_prioritized_event(priority, event)
end

#create_prioritized_event(priority, event) ⇒ Object 



154
155
156
157
158
159
160
161
 
# File 'lib/new_relic/agent/log_event_aggregator.rb', line 154

def create_prioritized_event(priority, event)
  [
    {
      PrioritySampledBuffer::PRIORITY_KEY => priority
    },
    event
  ]
end

#determine_severity(log) ⇒ Object 



117
118
119
 
# File 'lib/new_relic/agent/log_event_aggregator.rb', line 117

def determine_severity(log)
  log['level'] ? log['level'].to_s.upcase : 'UNKNOWN'
end

#harvest! ⇒ Object 



224
225
226
227
 
# File 'lib/new_relic/agent/log_event_aggregator.rb', line 224

def harvest!
  record_customer_metrics()
  super
end

#increment_event_counters(severity) ⇒ Object 



121
122
123
124
125
126
127
128
 
# File 'lib/new_relic/agent/log_event_aggregator.rb', line 121

def increment_event_counters(severity)
  return unless NewRelic::Agent.config[METRICS_ENABLED_KEY]

  @counter_lock.synchronize do
    @seen += 1
    @seen_by_severity[severity] += 1
  end
end

#labels ⇒ Object 



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

def labels
  @labels ||= create_labels
end

#logger_enabled? ⇒ Boolean

Returns:

  • (Boolean) 


238
239
240
 
# File 'lib/new_relic/agent/log_event_aggregator.rb', line 238

def logger_enabled?
  @enabled && @instrumentation_logger_enabled
end

#logstasher_enabled? ⇒ Boolean

Returns:

  • (Boolean) 


242
243
244
 
# File 'lib/new_relic/agent/log_event_aggregator.rb', line 242

def logstasher_enabled?
  @enabled && NewRelic::Agent::Instrumentation::LogStasher.enabled?
end

#monitoring_conditions_met?(severity) ⇒ Boolean

Returns:

  • (Boolean) 


113
114
115
 
# File 'lib/new_relic/agent/log_event_aggregator.rb', line 113

def monitoring_conditions_met?(severity)
  !severity_too_low?(severity) && NewRelic::Agent.config[FORWARDING_ENABLED_KEY] && !@high_security
end

#record(formatted_message, severity) ⇒ Object 



64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
 
# File 'lib/new_relic/agent/log_event_aggregator.rb', line 64

def record(formatted_message, severity)
  return unless logger_enabled?

  severity = 'UNKNOWN' if severity.nil? || severity.empty?
  increment_event_counters(severity)

  return if formatted_message.nil? || formatted_message.empty?
  return unless monitoring_conditions_met?(severity)

  txn = NewRelic::Agent::Transaction.tl_current
  priority = LogPriority.priority_for(txn)

  return txn.add_log_event(create_event(priority, formatted_message, severity)) if txn

  @lock.synchronize do
    @buffer.append(priority: priority) do
      create_event(priority, formatted_message, severity)
    end
  end
rescue
  nil
end

#record_batch(txn, logs) ⇒ Object 



130
131
132
133
134
135
136
137
138
139
140
141
142
 
# File 'lib/new_relic/agent/log_event_aggregator.rb', line 130

def record_batch(txn, logs)
  # Ensure we have the same shared priority
  priority = LogPriority.priority_for(txn)
  logs.each do |log|
    log.first[PRIORITY_KEY] = priority
  end

  @lock.synchronize do
    logs.each do |log|
      @buffer.append(event: log)
    end
  end
end

#record_logstasher_event(log) ⇒ Object 



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
 
# File 'lib/new_relic/agent/log_event_aggregator.rb', line 87

def record_logstasher_event(log)
  return unless logstasher_enabled?

  # LogStasher logs do not inherently include a message key, so most logs are recorded.
  # But when the key exists, we should not record the log if the message value is nil or empty.
  return if log.key?('message') && (log['message'].nil? || log['message'].empty?)

  severity = determine_severity(log)
  increment_event_counters(severity)

  return unless monitoring_conditions_met?(severity)

  txn = NewRelic::Agent::Transaction.tl_current
  priority = LogPriority.priority_for(txn)

  return txn.add_log_event(create_logstasher_event(priority, severity, log)) if txn

  @lock.synchronize do
    @buffer.append(priority: priority) do
      create_logstasher_event(priority, severity, log)
    end
  end
rescue
  nil
end

#reset! ⇒ Object 



229
230
231
232
233
234
235
236
 
# File 'lib/new_relic/agent/log_event_aggregator.rb', line 229

def reset!
  @counter_lock.synchronize do
    @seen = 0
    @seen_by_severity.clear
  end

  super
end