Class: Ably::Models::Stat

Inherits:
Object
  • Object
show all
Extended by:
Ably::Modules::Enum
Includes:
Ably::Modules::ModelCommon
Defined in:
lib/ably/models/stat.rb

Overview

A class representing an individual statistic for a specified #interval_id

Constant Summary collapse

GRANULARITY = 
ruby_enum('GRANULARITY',
  :minute,
  :hour,
  :day,
  :month
)
INTERVAL_FORMAT_STRING = 
[
  '%Y-%m-%d:%H:%M',
  '%Y-%m-%d:%H',
  '%Y-%m-%d',
  '%Y-%m'
]

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Ably::Modules::ModelCommon

#==, #[], #to_json

Methods included from Ably::Modules::MessagePack

#to_msgpack

Constructor Details

#initialize(hash_object) ⇒ Stat

Ably::Models::Stat initializer

Parameters:

  • hash_object (Hash) —

    object with the underlying stat details



116
117
118
119
120
 
# File 'lib/ably/models/stat.rb', line 116

def initialize(hash_object)
  @raw_hash_object  = hash_object

  set_hash_object hash_object
end

Instance Attribute Details

#all ⇒ Hash (readonly)

Returns Breakdown of summary stats for all message types.

Returns:

  • (Hash) —

    Breakdown of summary stats for all message types



35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
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
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
 
# File 'lib/ably/models/stat.rb', line 35

class Stat
  include Ably::Modules::ModelCommon
  extend Ably::Modules::Enum

  GRANULARITY = ruby_enum('GRANULARITY',
    :minute,
    :hour,
    :day,
    :month
  )

  INTERVAL_FORMAT_STRING = [
    '%Y-%m-%d:%H:%M',
    '%Y-%m-%d:%H',
    '%Y-%m-%d',
    '%Y-%m'
  ]

  class << self
    # Convert a Time with the specified Granularity into an interval ID based on UTC 0 time
    # @example
    #   Stat.to_interval_id(Time.now, :hour) # => '2015-01-01:10'
    #
    # @param time [Time] Time used to determine the interval
    # @param granularity [GRANULARITY] Granularity of the metrics such as :hour, :day
    #
    # @return [String] interval ID used for stats
    #
    def to_interval_id(time, granularity)
      raise ArgumentError, 'Time object required as first argument' unless time.kind_of?(Time)

      granularity = GRANULARITY(granularity)
      format = INTERVAL_FORMAT_STRING[granularity.to_i]

      time.utc.strftime(format)
    end

    # Returns the UTC 0 start Time of an interval_id
    # @example
    #   Stat.from_interval_id('2015-01-01:10') # => 2015-01-01 10:00:00 +0000
    #
    # @param interval_id [String]
    #
    # @return [Time] start time of the provided interval_id
    #
    def from_interval_id(interval_id)
      raise ArgumentError, 'Interval ID must be a string' unless interval_id.kind_of?(String)

      format = INTERVAL_FORMAT_STRING.find { |format| expected_length(format) == interval_id.length }
      raise ArgumentError, 'Interval ID is an invalid length' unless format

      Time.strptime("#{interval_id} +0000", "#{format} %z").utc
    end

    # Returns the {GRANULARITY} determined from the interval_id
    # @example
    #   Stat.granularity_from_interval_id('2015-01-01:10') # => :hour
    #
    # @param interval_id [String]
    #
    # @return [GRANULARITY] Granularity Enum for the interval_id
    #
    def granularity_from_interval_id(interval_id)
      raise ArgumentError, 'Interval ID must be a string' unless interval_id.kind_of?(String)

      format = INTERVAL_FORMAT_STRING.find { |format| expected_length(format) == interval_id.length }
      raise ArgumentError, 'Interval ID is an invalid length' unless format

      GRANULARITY[INTERVAL_FORMAT_STRING.index(format)]
    end

    private
    def expected_length(format)
      format.gsub('%Y', 'YYYY').length
    end
  end

  # {Stat} initializer
  #
  # @param hash_object  [Hash]  object with the underlying stat details
  #
  def initialize(hash_object)
    @raw_hash_object  = hash_object

    set_hash_object hash_object
  end

  %w( all inbound outbound persisted connections channels api_requests token_requests ).each do |attribute|
    define_method attribute do
      hash[attribute.to_sym]
    end
  end

  # @!attribute [r] interval_id
  # @return [String] The interval that this statistic applies to, see {GRANULARITY} and {INTERVAL_FORMAT_STRING}
  def interval_id
    hash.fetch(:interval_id)
  end

  # @!attribute [r] interval_time
  # @return [Time] A Time object representing the start of the interval
  def interval_time
    self.class.from_interval_id(interval_id)
  end

  # @!attribute [r] interval_granularity
  # @return [GRANULARITY] The granularity of the interval for the stat such as :day, :hour, :minute, see {GRANULARITY}
  def interval_granularity
    self.class.granularity_from_interval_id(interval_id)
  end

  def hash
    @hash_object
  end

  def as_json(*args)
    hash.as_json(*args)
  end

  private
  attr_reader :raw_hash_object

  def set_hash_object(hash)
    @hash_object = IdiomaticRubyWrapper(hash.clone.freeze)
  end
end

#api_requests ⇒ Hash (readonly)

Returns Aggregate data for numbers of API requests.

Returns:

  • (Hash) —

    Aggregate data for numbers of API requests



35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
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
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
 
# File 'lib/ably/models/stat.rb', line 35

class Stat
  include Ably::Modules::ModelCommon
  extend Ably::Modules::Enum

  GRANULARITY = ruby_enum('GRANULARITY',
    :minute,
    :hour,
    :day,
    :month
  )

  INTERVAL_FORMAT_STRING = [
    '%Y-%m-%d:%H:%M',
    '%Y-%m-%d:%H',
    '%Y-%m-%d',
    '%Y-%m'
  ]

  class << self
    # Convert a Time with the specified Granularity into an interval ID based on UTC 0 time
    # @example
    #   Stat.to_interval_id(Time.now, :hour) # => '2015-01-01:10'
    #
    # @param time [Time] Time used to determine the interval
    # @param granularity [GRANULARITY] Granularity of the metrics such as :hour, :day
    #
    # @return [String] interval ID used for stats
    #
    def to_interval_id(time, granularity)
      raise ArgumentError, 'Time object required as first argument' unless time.kind_of?(Time)

      granularity = GRANULARITY(granularity)
      format = INTERVAL_FORMAT_STRING[granularity.to_i]

      time.utc.strftime(format)
    end

    # Returns the UTC 0 start Time of an interval_id
    # @example
    #   Stat.from_interval_id('2015-01-01:10') # => 2015-01-01 10:00:00 +0000
    #
    # @param interval_id [String]
    #
    # @return [Time] start time of the provided interval_id
    #
    def from_interval_id(interval_id)
      raise ArgumentError, 'Interval ID must be a string' unless interval_id.kind_of?(String)

      format = INTERVAL_FORMAT_STRING.find { |format| expected_length(format) == interval_id.length }
      raise ArgumentError, 'Interval ID is an invalid length' unless format

      Time.strptime("#{interval_id} +0000", "#{format} %z").utc
    end

    # Returns the {GRANULARITY} determined from the interval_id
    # @example
    #   Stat.granularity_from_interval_id('2015-01-01:10') # => :hour
    #
    # @param interval_id [String]
    #
    # @return [GRANULARITY] Granularity Enum for the interval_id
    #
    def granularity_from_interval_id(interval_id)
      raise ArgumentError, 'Interval ID must be a string' unless interval_id.kind_of?(String)

      format = INTERVAL_FORMAT_STRING.find { |format| expected_length(format) == interval_id.length }
      raise ArgumentError, 'Interval ID is an invalid length' unless format

      GRANULARITY[INTERVAL_FORMAT_STRING.index(format)]
    end

    private
    def expected_length(format)
      format.gsub('%Y', 'YYYY').length
    end
  end

  # {Stat} initializer
  #
  # @param hash_object  [Hash]  object with the underlying stat details
  #
  def initialize(hash_object)
    @raw_hash_object  = hash_object

    set_hash_object hash_object
  end

  %w( all inbound outbound persisted connections channels api_requests token_requests ).each do |attribute|
    define_method attribute do
      hash[attribute.to_sym]
    end
  end

  # @!attribute [r] interval_id
  # @return [String] The interval that this statistic applies to, see {GRANULARITY} and {INTERVAL_FORMAT_STRING}
  def interval_id
    hash.fetch(:interval_id)
  end

  # @!attribute [r] interval_time
  # @return [Time] A Time object representing the start of the interval
  def interval_time
    self.class.from_interval_id(interval_id)
  end

  # @!attribute [r] interval_granularity
  # @return [GRANULARITY] The granularity of the interval for the stat such as :day, :hour, :minute, see {GRANULARITY}
  def interval_granularity
    self.class.granularity_from_interval_id(interval_id)
  end

  def hash
    @hash_object
  end

  def as_json(*args)
    hash.as_json(*args)
  end

  private
  attr_reader :raw_hash_object

  def set_hash_object(hash)
    @hash_object = IdiomaticRubyWrapper(hash.clone.freeze)
  end
end

#channels ⇒ Hash (readonly)

Returns Aggregate data for usage of Channels.

Returns:

  • (Hash) —

    Aggregate data for usage of Channels



35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
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
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
 
# File 'lib/ably/models/stat.rb', line 35

class Stat
  include Ably::Modules::ModelCommon
  extend Ably::Modules::Enum

  GRANULARITY = ruby_enum('GRANULARITY',
    :minute,
    :hour,
    :day,
    :month
  )

  INTERVAL_FORMAT_STRING = [
    '%Y-%m-%d:%H:%M',
    '%Y-%m-%d:%H',
    '%Y-%m-%d',
    '%Y-%m'
  ]

  class << self
    # Convert a Time with the specified Granularity into an interval ID based on UTC 0 time
    # @example
    #   Stat.to_interval_id(Time.now, :hour) # => '2015-01-01:10'
    #
    # @param time [Time] Time used to determine the interval
    # @param granularity [GRANULARITY] Granularity of the metrics such as :hour, :day
    #
    # @return [String] interval ID used for stats
    #
    def to_interval_id(time, granularity)
      raise ArgumentError, 'Time object required as first argument' unless time.kind_of?(Time)

      granularity = GRANULARITY(granularity)
      format = INTERVAL_FORMAT_STRING[granularity.to_i]

      time.utc.strftime(format)
    end

    # Returns the UTC 0 start Time of an interval_id
    # @example
    #   Stat.from_interval_id('2015-01-01:10') # => 2015-01-01 10:00:00 +0000
    #
    # @param interval_id [String]
    #
    # @return [Time] start time of the provided interval_id
    #
    def from_interval_id(interval_id)
      raise ArgumentError, 'Interval ID must be a string' unless interval_id.kind_of?(String)

      format = INTERVAL_FORMAT_STRING.find { |format| expected_length(format) == interval_id.length }
      raise ArgumentError, 'Interval ID is an invalid length' unless format

      Time.strptime("#{interval_id} +0000", "#{format} %z").utc
    end

    # Returns the {GRANULARITY} determined from the interval_id
    # @example
    #   Stat.granularity_from_interval_id('2015-01-01:10') # => :hour
    #
    # @param interval_id [String]
    #
    # @return [GRANULARITY] Granularity Enum for the interval_id
    #
    def granularity_from_interval_id(interval_id)
      raise ArgumentError, 'Interval ID must be a string' unless interval_id.kind_of?(String)

      format = INTERVAL_FORMAT_STRING.find { |format| expected_length(format) == interval_id.length }
      raise ArgumentError, 'Interval ID is an invalid length' unless format

      GRANULARITY[INTERVAL_FORMAT_STRING.index(format)]
    end

    private
    def expected_length(format)
      format.gsub('%Y', 'YYYY').length
    end
  end

  # {Stat} initializer
  #
  # @param hash_object  [Hash]  object with the underlying stat details
  #
  def initialize(hash_object)
    @raw_hash_object  = hash_object

    set_hash_object hash_object
  end

  %w( all inbound outbound persisted connections channels api_requests token_requests ).each do |attribute|
    define_method attribute do
      hash[attribute.to_sym]
    end
  end

  # @!attribute [r] interval_id
  # @return [String] The interval that this statistic applies to, see {GRANULARITY} and {INTERVAL_FORMAT_STRING}
  def interval_id
    hash.fetch(:interval_id)
  end

  # @!attribute [r] interval_time
  # @return [Time] A Time object representing the start of the interval
  def interval_time
    self.class.from_interval_id(interval_id)
  end

  # @!attribute [r] interval_granularity
  # @return [GRANULARITY] The granularity of the interval for the stat such as :day, :hour, :minute, see {GRANULARITY}
  def interval_granularity
    self.class.granularity_from_interval_id(interval_id)
  end

  def hash
    @hash_object
  end

  def as_json(*args)
    hash.as_json(*args)
  end

  private
  attr_reader :raw_hash_object

  def set_hash_object(hash)
    @hash_object = IdiomaticRubyWrapper(hash.clone.freeze)
  end
end

#connections ⇒ Hash (readonly)

Returns A breakdown of summary stats data for different (TLS vs non-TLS) connection types.

Returns:

  • (Hash) —

    A breakdown of summary stats data for different (TLS vs non-TLS) connection types.



35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
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
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
 
# File 'lib/ably/models/stat.rb', line 35

class Stat
  include Ably::Modules::ModelCommon
  extend Ably::Modules::Enum

  GRANULARITY = ruby_enum('GRANULARITY',
    :minute,
    :hour,
    :day,
    :month
  )

  INTERVAL_FORMAT_STRING = [
    '%Y-%m-%d:%H:%M',
    '%Y-%m-%d:%H',
    '%Y-%m-%d',
    '%Y-%m'
  ]

  class << self
    # Convert a Time with the specified Granularity into an interval ID based on UTC 0 time
    # @example
    #   Stat.to_interval_id(Time.now, :hour) # => '2015-01-01:10'
    #
    # @param time [Time] Time used to determine the interval
    # @param granularity [GRANULARITY] Granularity of the metrics such as :hour, :day
    #
    # @return [String] interval ID used for stats
    #
    def to_interval_id(time, granularity)
      raise ArgumentError, 'Time object required as first argument' unless time.kind_of?(Time)

      granularity = GRANULARITY(granularity)
      format = INTERVAL_FORMAT_STRING[granularity.to_i]

      time.utc.strftime(format)
    end

    # Returns the UTC 0 start Time of an interval_id
    # @example
    #   Stat.from_interval_id('2015-01-01:10') # => 2015-01-01 10:00:00 +0000
    #
    # @param interval_id [String]
    #
    # @return [Time] start time of the provided interval_id
    #
    def from_interval_id(interval_id)
      raise ArgumentError, 'Interval ID must be a string' unless interval_id.kind_of?(String)

      format = INTERVAL_FORMAT_STRING.find { |format| expected_length(format) == interval_id.length }
      raise ArgumentError, 'Interval ID is an invalid length' unless format

      Time.strptime("#{interval_id} +0000", "#{format} %z").utc
    end

    # Returns the {GRANULARITY} determined from the interval_id
    # @example
    #   Stat.granularity_from_interval_id('2015-01-01:10') # => :hour
    #
    # @param interval_id [String]
    #
    # @return [GRANULARITY] Granularity Enum for the interval_id
    #
    def granularity_from_interval_id(interval_id)
      raise ArgumentError, 'Interval ID must be a string' unless interval_id.kind_of?(String)

      format = INTERVAL_FORMAT_STRING.find { |format| expected_length(format) == interval_id.length }
      raise ArgumentError, 'Interval ID is an invalid length' unless format

      GRANULARITY[INTERVAL_FORMAT_STRING.index(format)]
    end

    private
    def expected_length(format)
      format.gsub('%Y', 'YYYY').length
    end
  end

  # {Stat} initializer
  #
  # @param hash_object  [Hash]  object with the underlying stat details
  #
  def initialize(hash_object)
    @raw_hash_object  = hash_object

    set_hash_object hash_object
  end

  %w( all inbound outbound persisted connections channels api_requests token_requests ).each do |attribute|
    define_method attribute do
      hash[attribute.to_sym]
    end
  end

  # @!attribute [r] interval_id
  # @return [String] The interval that this statistic applies to, see {GRANULARITY} and {INTERVAL_FORMAT_STRING}
  def interval_id
    hash.fetch(:interval_id)
  end

  # @!attribute [r] interval_time
  # @return [Time] A Time object representing the start of the interval
  def interval_time
    self.class.from_interval_id(interval_id)
  end

  # @!attribute [r] interval_granularity
  # @return [GRANULARITY] The granularity of the interval for the stat such as :day, :hour, :minute, see {GRANULARITY}
  def interval_granularity
    self.class.granularity_from_interval_id(interval_id)
  end

  def hash
    @hash_object
  end

  def as_json(*args)
    hash.as_json(*args)
  end

  private
  attr_reader :raw_hash_object

  def set_hash_object(hash)
    @hash_object = IdiomaticRubyWrapper(hash.clone.freeze)
  end
end

#inbound ⇒ Hash (readonly)

Returns Breakdown of summary stats for traffic over various transport types for all inbound messages.

Returns:

  • (Hash) —

    Breakdown of summary stats for traffic over various transport types for all inbound messages



35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
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
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
 
# File 'lib/ably/models/stat.rb', line 35

class Stat
  include Ably::Modules::ModelCommon
  extend Ably::Modules::Enum

  GRANULARITY = ruby_enum('GRANULARITY',
    :minute,
    :hour,
    :day,
    :month
  )

  INTERVAL_FORMAT_STRING = [
    '%Y-%m-%d:%H:%M',
    '%Y-%m-%d:%H',
    '%Y-%m-%d',
    '%Y-%m'
  ]

  class << self
    # Convert a Time with the specified Granularity into an interval ID based on UTC 0 time
    # @example
    #   Stat.to_interval_id(Time.now, :hour) # => '2015-01-01:10'
    #
    # @param time [Time] Time used to determine the interval
    # @param granularity [GRANULARITY] Granularity of the metrics such as :hour, :day
    #
    # @return [String] interval ID used for stats
    #
    def to_interval_id(time, granularity)
      raise ArgumentError, 'Time object required as first argument' unless time.kind_of?(Time)

      granularity = GRANULARITY(granularity)
      format = INTERVAL_FORMAT_STRING[granularity.to_i]

      time.utc.strftime(format)
    end

    # Returns the UTC 0 start Time of an interval_id
    # @example
    #   Stat.from_interval_id('2015-01-01:10') # => 2015-01-01 10:00:00 +0000
    #
    # @param interval_id [String]
    #
    # @return [Time] start time of the provided interval_id
    #
    def from_interval_id(interval_id)
      raise ArgumentError, 'Interval ID must be a string' unless interval_id.kind_of?(String)

      format = INTERVAL_FORMAT_STRING.find { |format| expected_length(format) == interval_id.length }
      raise ArgumentError, 'Interval ID is an invalid length' unless format

      Time.strptime("#{interval_id} +0000", "#{format} %z").utc
    end

    # Returns the {GRANULARITY} determined from the interval_id
    # @example
    #   Stat.granularity_from_interval_id('2015-01-01:10') # => :hour
    #
    # @param interval_id [String]
    #
    # @return [GRANULARITY] Granularity Enum for the interval_id
    #
    def granularity_from_interval_id(interval_id)
      raise ArgumentError, 'Interval ID must be a string' unless interval_id.kind_of?(String)

      format = INTERVAL_FORMAT_STRING.find { |format| expected_length(format) == interval_id.length }
      raise ArgumentError, 'Interval ID is an invalid length' unless format

      GRANULARITY[INTERVAL_FORMAT_STRING.index(format)]
    end

    private
    def expected_length(format)
      format.gsub('%Y', 'YYYY').length
    end
  end

  # {Stat} initializer
  #
  # @param hash_object  [Hash]  object with the underlying stat details
  #
  def initialize(hash_object)
    @raw_hash_object  = hash_object

    set_hash_object hash_object
  end

  %w( all inbound outbound persisted connections channels api_requests token_requests ).each do |attribute|
    define_method attribute do
      hash[attribute.to_sym]
    end
  end

  # @!attribute [r] interval_id
  # @return [String] The interval that this statistic applies to, see {GRANULARITY} and {INTERVAL_FORMAT_STRING}
  def interval_id
    hash.fetch(:interval_id)
  end

  # @!attribute [r] interval_time
  # @return [Time] A Time object representing the start of the interval
  def interval_time
    self.class.from_interval_id(interval_id)
  end

  # @!attribute [r] interval_granularity
  # @return [GRANULARITY] The granularity of the interval for the stat such as :day, :hour, :minute, see {GRANULARITY}
  def interval_granularity
    self.class.granularity_from_interval_id(interval_id)
  end

  def hash
    @hash_object
  end

  def as_json(*args)
    hash.as_json(*args)
  end

  private
  attr_reader :raw_hash_object

  def set_hash_object(hash)
    @hash_object = IdiomaticRubyWrapper(hash.clone.freeze)
  end
end

#interval_granularity ⇒ GRANULARITY (readonly)

Returns The granularity of the interval for the stat such as :day, :hour, :minute, see GRANULARITY.

Returns:

  • (GRANULARITY) —

    The granularity of the interval for the stat such as :day, :hour, :minute, see GRANULARITY



142
143
144
 
# File 'lib/ably/models/stat.rb', line 142

def interval_granularity
  self.class.granularity_from_interval_id(interval_id)
end

#interval_id ⇒ String (readonly)

Returns The interval that this statistic applies to, see GRANULARITY and INTERVAL_FORMAT_STRING.

Returns:



130
131
132
 
# File 'lib/ably/models/stat.rb', line 130

def interval_id
  hash.fetch(:interval_id)
end

#interval_time ⇒ Time (readonly)

Returns A Time object representing the start of the interval.

Returns:

  • (Time) —

    A Time object representing the start of the interval



136
137
138
 
# File 'lib/ably/models/stat.rb', line 136

def interval_time
  self.class.from_interval_id(interval_id)
end

#outbound ⇒ Hash (readonly)

Returns Breakdown of summary stats for traffic over various transport types for all outbound messages.

Returns:

  • (Hash) —

    Breakdown of summary stats for traffic over various transport types for all outbound messages



35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
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
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
 
# File 'lib/ably/models/stat.rb', line 35

class Stat
  include Ably::Modules::ModelCommon
  extend Ably::Modules::Enum

  GRANULARITY = ruby_enum('GRANULARITY',
    :minute,
    :hour,
    :day,
    :month
  )

  INTERVAL_FORMAT_STRING = [
    '%Y-%m-%d:%H:%M',
    '%Y-%m-%d:%H',
    '%Y-%m-%d',
    '%Y-%m'
  ]

  class << self
    # Convert a Time with the specified Granularity into an interval ID based on UTC 0 time
    # @example
    #   Stat.to_interval_id(Time.now, :hour) # => '2015-01-01:10'
    #
    # @param time [Time] Time used to determine the interval
    # @param granularity [GRANULARITY] Granularity of the metrics such as :hour, :day
    #
    # @return [String] interval ID used for stats
    #
    def to_interval_id(time, granularity)
      raise ArgumentError, 'Time object required as first argument' unless time.kind_of?(Time)

      granularity = GRANULARITY(granularity)
      format = INTERVAL_FORMAT_STRING[granularity.to_i]

      time.utc.strftime(format)
    end

    # Returns the UTC 0 start Time of an interval_id
    # @example
    #   Stat.from_interval_id('2015-01-01:10') # => 2015-01-01 10:00:00 +0000
    #
    # @param interval_id [String]
    #
    # @return [Time] start time of the provided interval_id
    #
    def from_interval_id(interval_id)
      raise ArgumentError, 'Interval ID must be a string' unless interval_id.kind_of?(String)

      format = INTERVAL_FORMAT_STRING.find { |format| expected_length(format) == interval_id.length }
      raise ArgumentError, 'Interval ID is an invalid length' unless format

      Time.strptime("#{interval_id} +0000", "#{format} %z").utc
    end

    # Returns the {GRANULARITY} determined from the interval_id
    # @example
    #   Stat.granularity_from_interval_id('2015-01-01:10') # => :hour
    #
    # @param interval_id [String]
    #
    # @return [GRANULARITY] Granularity Enum for the interval_id
    #
    def granularity_from_interval_id(interval_id)
      raise ArgumentError, 'Interval ID must be a string' unless interval_id.kind_of?(String)

      format = INTERVAL_FORMAT_STRING.find { |format| expected_length(format) == interval_id.length }
      raise ArgumentError, 'Interval ID is an invalid length' unless format

      GRANULARITY[INTERVAL_FORMAT_STRING.index(format)]
    end

    private
    def expected_length(format)
      format.gsub('%Y', 'YYYY').length
    end
  end

  # {Stat} initializer
  #
  # @param hash_object  [Hash]  object with the underlying stat details
  #
  def initialize(hash_object)
    @raw_hash_object  = hash_object

    set_hash_object hash_object
  end

  %w( all inbound outbound persisted connections channels api_requests token_requests ).each do |attribute|
    define_method attribute do
      hash[attribute.to_sym]
    end
  end

  # @!attribute [r] interval_id
  # @return [String] The interval that this statistic applies to, see {GRANULARITY} and {INTERVAL_FORMAT_STRING}
  def interval_id
    hash.fetch(:interval_id)
  end

  # @!attribute [r] interval_time
  # @return [Time] A Time object representing the start of the interval
  def interval_time
    self.class.from_interval_id(interval_id)
  end

  # @!attribute [r] interval_granularity
  # @return [GRANULARITY] The granularity of the interval for the stat such as :day, :hour, :minute, see {GRANULARITY}
  def interval_granularity
    self.class.granularity_from_interval_id(interval_id)
  end

  def hash
    @hash_object
  end

  def as_json(*args)
    hash.as_json(*args)
  end

  private
  attr_reader :raw_hash_object

  def set_hash_object(hash)
    @hash_object = IdiomaticRubyWrapper(hash.clone.freeze)
  end
end

#persisted ⇒ Hash (readonly)

Returns Breakdown of summary stats for all persisted messages.

Returns:

  • (Hash) —

    Breakdown of summary stats for all persisted messages



35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
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
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
 
# File 'lib/ably/models/stat.rb', line 35

class Stat
  include Ably::Modules::ModelCommon
  extend Ably::Modules::Enum

  GRANULARITY = ruby_enum('GRANULARITY',
    :minute,
    :hour,
    :day,
    :month
  )

  INTERVAL_FORMAT_STRING = [
    '%Y-%m-%d:%H:%M',
    '%Y-%m-%d:%H',
    '%Y-%m-%d',
    '%Y-%m'
  ]

  class << self
    # Convert a Time with the specified Granularity into an interval ID based on UTC 0 time
    # @example
    #   Stat.to_interval_id(Time.now, :hour) # => '2015-01-01:10'
    #
    # @param time [Time] Time used to determine the interval
    # @param granularity [GRANULARITY] Granularity of the metrics such as :hour, :day
    #
    # @return [String] interval ID used for stats
    #
    def to_interval_id(time, granularity)
      raise ArgumentError, 'Time object required as first argument' unless time.kind_of?(Time)

      granularity = GRANULARITY(granularity)
      format = INTERVAL_FORMAT_STRING[granularity.to_i]

      time.utc.strftime(format)
    end

    # Returns the UTC 0 start Time of an interval_id
    # @example
    #   Stat.from_interval_id('2015-01-01:10') # => 2015-01-01 10:00:00 +0000
    #
    # @param interval_id [String]
    #
    # @return [Time] start time of the provided interval_id
    #
    def from_interval_id(interval_id)
      raise ArgumentError, 'Interval ID must be a string' unless interval_id.kind_of?(String)

      format = INTERVAL_FORMAT_STRING.find { |format| expected_length(format) == interval_id.length }
      raise ArgumentError, 'Interval ID is an invalid length' unless format

      Time.strptime("#{interval_id} +0000", "#{format} %z").utc
    end

    # Returns the {GRANULARITY} determined from the interval_id
    # @example
    #   Stat.granularity_from_interval_id('2015-01-01:10') # => :hour
    #
    # @param interval_id [String]
    #
    # @return [GRANULARITY] Granularity Enum for the interval_id
    #
    def granularity_from_interval_id(interval_id)
      raise ArgumentError, 'Interval ID must be a string' unless interval_id.kind_of?(String)

      format = INTERVAL_FORMAT_STRING.find { |format| expected_length(format) == interval_id.length }
      raise ArgumentError, 'Interval ID is an invalid length' unless format

      GRANULARITY[INTERVAL_FORMAT_STRING.index(format)]
    end

    private
    def expected_length(format)
      format.gsub('%Y', 'YYYY').length
    end
  end

  # {Stat} initializer
  #
  # @param hash_object  [Hash]  object with the underlying stat details
  #
  def initialize(hash_object)
    @raw_hash_object  = hash_object

    set_hash_object hash_object
  end

  %w( all inbound outbound persisted connections channels api_requests token_requests ).each do |attribute|
    define_method attribute do
      hash[attribute.to_sym]
    end
  end

  # @!attribute [r] interval_id
  # @return [String] The interval that this statistic applies to, see {GRANULARITY} and {INTERVAL_FORMAT_STRING}
  def interval_id
    hash.fetch(:interval_id)
  end

  # @!attribute [r] interval_time
  # @return [Time] A Time object representing the start of the interval
  def interval_time
    self.class.from_interval_id(interval_id)
  end

  # @!attribute [r] interval_granularity
  # @return [GRANULARITY] The granularity of the interval for the stat such as :day, :hour, :minute, see {GRANULARITY}
  def interval_granularity
    self.class.granularity_from_interval_id(interval_id)
  end

  def hash
    @hash_object
  end

  def as_json(*args)
    hash.as_json(*args)
  end

  private
  attr_reader :raw_hash_object

  def set_hash_object(hash)
    @hash_object = IdiomaticRubyWrapper(hash.clone.freeze)
  end
end

#token_requests ⇒ Hash (readonly)

Returns Aggregate data for numbers of Token requests.

Returns:

  • (Hash) —

    Aggregate data for numbers of Token requests



35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
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
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
 
# File 'lib/ably/models/stat.rb', line 35

class Stat
  include Ably::Modules::ModelCommon
  extend Ably::Modules::Enum

  GRANULARITY = ruby_enum('GRANULARITY',
    :minute,
    :hour,
    :day,
    :month
  )

  INTERVAL_FORMAT_STRING = [
    '%Y-%m-%d:%H:%M',
    '%Y-%m-%d:%H',
    '%Y-%m-%d',
    '%Y-%m'
  ]

  class << self
    # Convert a Time with the specified Granularity into an interval ID based on UTC 0 time
    # @example
    #   Stat.to_interval_id(Time.now, :hour) # => '2015-01-01:10'
    #
    # @param time [Time] Time used to determine the interval
    # @param granularity [GRANULARITY] Granularity of the metrics such as :hour, :day
    #
    # @return [String] interval ID used for stats
    #
    def to_interval_id(time, granularity)
      raise ArgumentError, 'Time object required as first argument' unless time.kind_of?(Time)

      granularity = GRANULARITY(granularity)
      format = INTERVAL_FORMAT_STRING[granularity.to_i]

      time.utc.strftime(format)
    end

    # Returns the UTC 0 start Time of an interval_id
    # @example
    #   Stat.from_interval_id('2015-01-01:10') # => 2015-01-01 10:00:00 +0000
    #
    # @param interval_id [String]
    #
    # @return [Time] start time of the provided interval_id
    #
    def from_interval_id(interval_id)
      raise ArgumentError, 'Interval ID must be a string' unless interval_id.kind_of?(String)

      format = INTERVAL_FORMAT_STRING.find { |format| expected_length(format) == interval_id.length }
      raise ArgumentError, 'Interval ID is an invalid length' unless format

      Time.strptime("#{interval_id} +0000", "#{format} %z").utc
    end

    # Returns the {GRANULARITY} determined from the interval_id
    # @example
    #   Stat.granularity_from_interval_id('2015-01-01:10') # => :hour
    #
    # @param interval_id [String]
    #
    # @return [GRANULARITY] Granularity Enum for the interval_id
    #
    def granularity_from_interval_id(interval_id)
      raise ArgumentError, 'Interval ID must be a string' unless interval_id.kind_of?(String)

      format = INTERVAL_FORMAT_STRING.find { |format| expected_length(format) == interval_id.length }
      raise ArgumentError, 'Interval ID is an invalid length' unless format

      GRANULARITY[INTERVAL_FORMAT_STRING.index(format)]
    end

    private
    def expected_length(format)
      format.gsub('%Y', 'YYYY').length
    end
  end

  # {Stat} initializer
  #
  # @param hash_object  [Hash]  object with the underlying stat details
  #
  def initialize(hash_object)
    @raw_hash_object  = hash_object

    set_hash_object hash_object
  end

  %w( all inbound outbound persisted connections channels api_requests token_requests ).each do |attribute|
    define_method attribute do
      hash[attribute.to_sym]
    end
  end

  # @!attribute [r] interval_id
  # @return [String] The interval that this statistic applies to, see {GRANULARITY} and {INTERVAL_FORMAT_STRING}
  def interval_id
    hash.fetch(:interval_id)
  end

  # @!attribute [r] interval_time
  # @return [Time] A Time object representing the start of the interval
  def interval_time
    self.class.from_interval_id(interval_id)
  end

  # @!attribute [r] interval_granularity
  # @return [GRANULARITY] The granularity of the interval for the stat such as :day, :hour, :minute, see {GRANULARITY}
  def interval_granularity
    self.class.granularity_from_interval_id(interval_id)
  end

  def hash
    @hash_object
  end

  def as_json(*args)
    hash.as_json(*args)
  end

  private
  attr_reader :raw_hash_object

  def set_hash_object(hash)
    @hash_object = IdiomaticRubyWrapper(hash.clone.freeze)
  end
end

Class Method Details

.from_interval_id(interval_id) ⇒ Time

Returns the UTC 0 start Time of an interval_id

Examples:

Stat.from_interval_id('2015-01-01:10') # => 2015-01-01 10:00:00 +0000

Parameters:

  • interval_id (String)

Returns:

  • (Time) —

    start time of the provided interval_id

Raises:

  • (ArgumentError) 


80
81
82
83
84
85
86
87
 
# File 'lib/ably/models/stat.rb', line 80

def from_interval_id(interval_id)
  raise ArgumentError, 'Interval ID must be a string' unless interval_id.kind_of?(String)

  format = INTERVAL_FORMAT_STRING.find { |format| expected_length(format) == interval_id.length }
  raise ArgumentError, 'Interval ID is an invalid length' unless format

  Time.strptime("#{interval_id} +0000", "#{format} %z").utc
end

.granularity_from_interval_id(interval_id) ⇒ GRANULARITY

Returns the GRANULARITY determined from the interval_id

Examples:

Stat.granularity_from_interval_id('2015-01-01:10') # => :hour

Parameters:

  • interval_id (String)

Returns:

  • (GRANULARITY) —

    Granularity Enum for the interval_id

Raises:

  • (ArgumentError) 


97
98
99
100
101
102
103
104
 
# File 'lib/ably/models/stat.rb', line 97

def granularity_from_interval_id(interval_id)
  raise ArgumentError, 'Interval ID must be a string' unless interval_id.kind_of?(String)

  format = INTERVAL_FORMAT_STRING.find { |format| expected_length(format) == interval_id.length }
  raise ArgumentError, 'Interval ID is an invalid length' unless format

  GRANULARITY[INTERVAL_FORMAT_STRING.index(format)]
end

.to_interval_id(time, granularity) ⇒ String

Convert a Time with the specified Granularity into an interval ID based on UTC 0 time

Examples:

Stat.to_interval_id(Time.now, :hour) # => '2015-01-01:10'

Parameters:

  • time (Time) —

    Time used to determine the interval

  • granularity (GRANULARITY) —

    Granularity of the metrics such as :hour, :day

Returns:

  • (String) —

    interval ID used for stats

Raises:

  • (ArgumentError) 


63
64
65
66
67
68
69
70
 
# File 'lib/ably/models/stat.rb', line 63

def to_interval_id(time, granularity)
  raise ArgumentError, 'Time object required as first argument' unless time.kind_of?(Time)

  granularity = GRANULARITY(granularity)
  format = INTERVAL_FORMAT_STRING[granularity.to_i]

  time.utc.strftime(format)
end

Instance Method Details

#as_json(*args) ⇒ Object 



150
151
152
 
# File 'lib/ably/models/stat.rb', line 150

def as_json(*args)
  hash.as_json(*args)
end

#hash ⇒ Object 



146
147
148
 
# File 'lib/ably/models/stat.rb', line 146

def hash
  @hash_object
end