Module: Necropsy::Analyzers::Dynamic::ObservationPolicy

Defined in:
lib/necropsy/analyzers/dynamic/observation_policy.rb

Class Method Summary collapse

Class Method Details

.compatible_merge(left, right) ⇒ Object 



51
52
53
54
55
56
57
58
59
60
 
# File 'lib/necropsy/analyzers/dynamic/observation_policy.rb', line 51

def compatible_merge(left, right)
  return left.merge(right) unless left.is_a?(Hash) && right.is_a?(Hash)

  %w[source_revision source_revision_status environment collector_name collector_version].each do |key|
    next if left[key].nil? || right[key].nil? || left[key] == right[key]

    raise Error, "Dynamic observation #{key} is incompatible"
  end
  left.merge(right)
end

.evidence_scope(observation) ⇒ Object 



62
63
64
65
66
67
68
69
70
71
72
73
74
75
 
# File 'lib/necropsy/analyzers/dynamic/observation_policy.rb', line 62

def evidence_scope(observation)
  declared_scope = observation['scope']
  declared_scope = {} unless declared_scope.is_a?(Hash)
  declared_scope = declared_scope.reject do |key, _value|
    %w[revision source_revision].include?(key.to_s)
  end
  selectors = {
    'revision' => observation['source_revision'],
    'source_revision_status' => observation['source_revision_status'],
    'environment' => observation['environment'],
    'collector' => observation['collector']
  }.compact
  declared_scope.merge(selectors)
end

.metadata(payload = nil, expected_revision: nil, **keyword_payload) ⇒ Object

Raises:



9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
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
 
# File 'lib/necropsy/analyzers/dynamic/observation_policy.rb', line 9

def metadata(payload = nil, expected_revision: nil, **keyword_payload)
  payload ||= keyword_payload
  observation = payload['observation']
  observation = {} unless observation.is_a?(Hash)
  schema_version = Integer(payload.fetch('schema_version', 1), exception: false)
  raise Error, 'Dynamic observation schema version must be 1 or 2' unless [1, 2].include?(schema_version)

  revision = source_revision(payload, observation)

  status = source_revision_status(payload, observation, revision, expected_revision)
  normalized = observation.merge(
    'schema_version' => schema_version,
    'positive_evidence_policy' => 'alive_only',
    'source_revision_status' => status,
    'source_revision_policy' => 'accepted_for_liveness_only'
  )
  normalized = normalized.merge('source_revision' => revision) if revision
  normalized = normalized.merge('expected_source_revision' => expected_revision) if expected_revision
  return normalized unless schema_version == 2

  collector = payload['collector']
  collector = {} unless collector.is_a?(Hash)
  source = payload['source']
  source = {} unless source.is_a?(Hash)
  scope = payload['scope']
  scope = {} unless scope.is_a?(Hash)
  quality = payload['quality']
  quality = {} unless quality.is_a?(Hash)
  normalized.merge(
    'collector_name' => collector['name'] || payload['collector_name'],
    'collector_version' => collector['version'] || payload['collector_version'],
    'source_metadata' => source,
    'environment' => scope['environment'] || observation['environment'],
    'sample_unit' => scope['sample_unit'] || observation['sample_unit'],
    'sample_rate' => scope['sample_rate'] || observation['sample_rate'],
    'quality' => {
      'dropped_events' => quality.fetch('dropped_events', 0),
      'overflowed' => quality.fetch('overflowed', false)
    }
  ).compact
end