Class: EventMeter::ReportDefinition

Inherits:
Object
  • Object
show all
Defined in:
lib/event_meter/report_definition.rb

Defined Under Namespace

Classes: BuiltIndex, Index, Interval

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(name:, version:) ⇒ ReportDefinition

Returns a new instance of ReportDefinition.



62
63
64
65
66
67
 
# File 'lib/event_meter/report_definition.rb', line 62

def initialize(name:, version:)
  @name = normalize_name(name)
  @version = normalize_version(version)
  @indexes = [Index.new(params: [])]
  @intervals = []
end

Instance Attribute Details

#indexes ⇒ Object (readonly)

Returns the value of attribute indexes.



44
45
46
 
# File 'lib/event_meter/report_definition.rb', line 44

def indexes
  @indexes
end

#intervals ⇒ Object (readonly)

Returns the value of attribute intervals.



44
45
46
 
# File 'lib/event_meter/report_definition.rb', line 44

def intervals
  @intervals
end

#name ⇒ Object (readonly)

Returns the value of attribute name.



44
45
46
 
# File 'lib/event_meter/report_definition.rb', line 44

def name
  @name
end

#version ⇒ Object (readonly)

Returns the value of attribute version.



44
45
46
 
# File 'lib/event_meter/report_definition.rb', line 44

def version
  @version
end

Class Method Details

.build(name, version:) {|definition| ... } ⇒ Object

Yields:

  • (definition) 


46
47
48
49
50
 
# File 'lib/event_meter/report_definition.rb', line 46

def self.build(name, version:)
  definition = new(name: name, version: version)
  yield definition if block_given?
  definition
end

.from_h(hash) ⇒ Object 



52
53
54
55
56
57
58
59
60
 
# File 'lib/event_meter/report_definition.rb', line 52

def self.from_h(hash)
  hash = HashInput.coerce(hash, "report definition")

  new(name: hash.fetch("name"), version: hash.fetch("version")).tap do |definition|
    definition.send(:replace_indexes, hash.fetch("indexes", []))
    definition.send(:replace_intervals, hash.fetch("intervals", []))
    definition.send(:validate_fingerprint!, hash.fetch("fingerprint"))
  end
end

.indexable_value?(values, param) ⇒ Boolean

Returns:

  • (Boolean) 


122
123
124
 
# File 'lib/event_meter/report_definition.rb', line 122

def self.indexable_value?(values, param)
  values.key?(param.to_s) && !values[param.to_s].nil?
end

.normalize_param(param) ⇒ Object

Raises:

  • (ArgumentError) 


116
117
118
119
120
 
# File 'lib/event_meter/report_definition.rb', line 116

def self.normalize_param(param)
  return param.to_sym if param.respond_to?(:to_sym) && !param.to_s.strip.empty?

  raise ArgumentError, "report params must be strings or symbols"
end

.normalize_params(params) ⇒ Object 



111
112
113
114
 
# File 'lib/event_meter/report_definition.rb', line 111

def self.normalize_params(params)
  params = params.first if params.is_a?(Array) && params.length == 1 && params.first.is_a?(Array)
  Array(params).map { |param| normalize_param(param) }.uniq.sort
end

Instance Method Details

#fingerprint ⇒ Object 



103
104
105
 
# File 'lib/event_meter/report_definition.rb', line 103

def fingerprint
  Digest::SHA256.hexdigest(JSON.generate(canonical_h))
end

#index_by(*params) ⇒ Object 



69
70
71
72
73
74
75
 
# File 'lib/event_meter/report_definition.rb', line 69

def index_by(*params)
  normalized = self.class.normalize_params(params)
  return self if indexes.any? { |index| index.params == normalized }

  indexes << Index.new(params: normalized)
  self
end

#index_for!(by) ⇒ Object 



92
93
94
95
96
97
98
99
100
101
 
# File 'lib/event_meter/report_definition.rb', line 92

def index_for!(by)
  normalized_by = normalize_by(by)
  index = indexes.find { |candidate| candidate.matches?(normalized_by) }

  unless index
    raise UnsupportedQueryError, "no index configured for #{name} v#{version} by #{normalized_by.keys.inspect}"
  end

  BuiltIndex.new(index: index, key: index.key_for(normalized_by))
end

#indexes_for(payload) ⇒ Object 



84
85
86
87
88
89
90
 
# File 'lib/event_meter/report_definition.rb', line 84

def indexes_for(payload)
  indexes.filter_map do |index|
    next unless index.params.all? { |param| self.class.indexable_value?(payload.params, param) }

    BuiltIndex.new(index: index, key: index.key_for(payload.params))
  end
end

#measure_interval_by(param, group_by: []) ⇒ Object 



77
78
79
80
81
82
 
# File 'lib/event_meter/report_definition.rb', line 77

def measure_interval_by(param, group_by: [])
  interval = Interval.new(param: param, group_by: group_by)
  intervals << interval unless intervals.any? { |existing| existing == interval }
  index_by(*interval.group_by) unless interval.group_by.empty?
  self
end

#to_h ⇒ Object 



107
108
109
 
# File 'lib/event_meter/report_definition.rb', line 107

def to_h
  canonical_h.merge("fingerprint" => fingerprint)
end