Class: Gitlab::Instrumentation::RedisBase

Inherits:
Object
  • Object
show all
Extended by:
RedisPayload, Utils::StrongMemoize
Defined in:
lib/gitlab/instrumentation/redis_base.rb

Class Method Summary collapse

Methods included from RedisPayload

payload

Class Method Details

.add_call_details(duration, commands) ⇒ Object 



23
24
25
26
27
28
29
30
31
 
# File 'lib/gitlab/instrumentation/redis_base.rb', line 23

def add_call_details(duration, commands)
  return unless Gitlab::PerformanceBar.enabled_for_request?

  detail_store << {
    commands: commands,
    duration: duration,
    backtrace: ::Gitlab::BacktraceCleaner.clean_backtrace(caller)
  }
end

.add_duration(duration) ⇒ Object 



18
19
20
21
 
# File 'lib/gitlab/instrumentation/redis_base.rb', line 18

def add_duration(duration)
  ::RequestStore[call_duration_key] ||= 0
  ::RequestStore[call_duration_key] += duration
end

.detail_store ⇒ Object 



70
71
72
 
# File 'lib/gitlab/instrumentation/redis_base.rb', line 70

def detail_store
  ::RequestStore[call_details_key] ||= []
end

.enable_redis_cluster_validation ⇒ Object 



102
103
104
105
106
 
# File 'lib/gitlab/instrumentation/redis_base.rb', line 102

def enable_redis_cluster_validation
  @redis_cluster_validation = true

  self
end

.get_allowed_cross_slot_request_count ⇒ Object 



78
79
80
 
# File 'lib/gitlab/instrumentation/redis_base.rb', line 78

def get_allowed_cross_slot_request_count
  ::RequestStore[allowed_cross_slots_key] || 0
end

.get_cross_slot_request_count ⇒ Object 



74
75
76
 
# File 'lib/gitlab/instrumentation/redis_base.rb', line 74

def get_cross_slot_request_count
  ::RequestStore[cross_slots_key] || 0
end

.get_request_count ⇒ Object 



58
59
60
 
# File 'lib/gitlab/instrumentation/redis_base.rb', line 58

def get_request_count
  ::RequestStore[request_count_key] || 0
end

.increment_allowed_cross_slot_request_count(amount = 1) ⇒ Object 



53
54
55
56
 
# File 'lib/gitlab/instrumentation/redis_base.rb', line 53

def increment_allowed_cross_slot_request_count(amount = 1)
  ::RequestStore[allowed_cross_slots_key] ||= 0
  ::RequestStore[allowed_cross_slots_key] += amount
end

.increment_cross_slot_request_count(amount = 1) ⇒ Object 



48
49
50
51
 
# File 'lib/gitlab/instrumentation/redis_base.rb', line 48

def increment_cross_slot_request_count(amount = 1)
  ::RequestStore[cross_slots_key] ||= 0
  ::RequestStore[cross_slots_key] += amount
end

.increment_read_bytes(num_bytes) ⇒ Object 



38
39
40
41
 
# File 'lib/gitlab/instrumentation/redis_base.rb', line 38

def increment_read_bytes(num_bytes)
  ::RequestStore[read_bytes_key] ||= 0
  ::RequestStore[read_bytes_key] += num_bytes
end

.increment_request_count(amount = 1) ⇒ Object 



33
34
35
36
 
# File 'lib/gitlab/instrumentation/redis_base.rb', line 33

def increment_request_count(amount = 1)
  ::RequestStore[request_count_key] ||= 0
  ::RequestStore[request_count_key] += amount
end

.increment_write_bytes(num_bytes) ⇒ Object 



43
44
45
46
 
# File 'lib/gitlab/instrumentation/redis_base.rb', line 43

def increment_write_bytes(num_bytes)
  ::RequestStore[write_bytes_key] ||= 0
  ::RequestStore[write_bytes_key] += num_bytes
end

.instance_count_cluster_redirection(ex) ⇒ Object 



131
132
133
134
135
136
137
 
# File 'lib/gitlab/instrumentation/redis_base.rb', line 131

def instance_count_cluster_redirection(ex)
  # This metric is meant to give a client side view of how often are commands
  # redirected to the right node, especially during resharding..
  # This metric can be used for Redis alerting and service health monitoring.
  @redirection_counter ||= Gitlab::Metrics.counter(:gitlab_redis_client_redirections_total, 'Client side Redis Cluster redirection count, per Redis node, per slot')
  @redirection_counter.increment(decompose_redirection_message(ex.message).merge({ storage: storage_key }))
end

.instance_count_exception(ex) ⇒ Object 



123
124
125
126
127
128
129
 
# File 'lib/gitlab/instrumentation/redis_base.rb', line 123

def instance_count_exception(ex)
  # This metric is meant to give a client side view of how the Redis
  # server is doing. Redis itself does not expose error counts. This
  # metric can be used for Redis alerting and service health monitoring.
  @exception_counter ||= Gitlab::Metrics.counter(:gitlab_redis_client_exceptions_total, 'Client side Redis exception count, per Redis server, per exception class')
  @exception_counter.increment({ storage: storage_key, exception: ex.class.to_s })
end

.instance_count_pipelined_request(size) ⇒ Object 



113
114
115
116
117
118
119
120
121
 
# File 'lib/gitlab/instrumentation/redis_base.rb', line 113

def instance_count_pipelined_request(size)
  @pipeline_size_histogram ||= Gitlab::Metrics.histogram(
    :gitlab_redis_client_requests_pipelined_commands,
    'Client side Redis request pipeline size, per Redis server',
    {},
    [10, 100, 1000, 10_000]
  )
  @pipeline_size_histogram.observe({ storage: storage_key }, size)
end

.instance_count_request(amount = 1) ⇒ Object 



108
109
110
111
 
# File 'lib/gitlab/instrumentation/redis_base.rb', line 108

def instance_count_request(amount = 1)
  @request_counter ||= Gitlab::Metrics.counter(:gitlab_redis_client_requests_total, 'Client side Redis request count, per Redis server')
  @request_counter.increment({ storage: storage_key }, amount)
end

.instance_observe_duration(duration) ⇒ Object 



139
140
141
142
143
144
145
146
147
148
 
# File 'lib/gitlab/instrumentation/redis_base.rb', line 139

def instance_observe_duration(duration)
  @request_latency_histogram ||= Gitlab::Metrics.histogram(
    :gitlab_redis_client_requests_duration_seconds,
    'Client side Redis request latency, per Redis server, excluding blocking commands',
    {},
    [0.1, 0.5, 0.75, 1]
  )

  @request_latency_histogram.observe({ storage: storage_key }, duration)
end

.log_exception(ex) ⇒ Object 



150
151
152
 
# File 'lib/gitlab/instrumentation/redis_base.rb', line 150

def log_exception(ex)
  ::Gitlab::ErrorTracking.log_exception(ex, storage: storage_key)
end

.query_time ⇒ Object 



82
83
84
85
 
# File 'lib/gitlab/instrumentation/redis_base.rb', line 82

def query_time
  query_time = ::RequestStore[call_duration_key] || 0
  query_time.round(::Gitlab::InstrumentationHelper::DURATION_PRECISION)
end

.read_bytes ⇒ Object 



62
63
64
 
# File 'lib/gitlab/instrumentation/redis_base.rb', line 62

def read_bytes
  ::RequestStore[read_bytes_key] || 0
end

.redis_cluster_validate!(commands) ⇒ Object 



87
88
89
90
91
92
93
94
95
96
97
98
99
100
 
# File 'lib/gitlab/instrumentation/redis_base.rb', line 87

def redis_cluster_validate!(commands)
  return true unless @redis_cluster_validation

  result = ::Gitlab::Instrumentation::RedisClusterValidator.validate(commands)
  return true if result.nil?

  if !result[:valid] && !result[:allowed] && (Rails.env.development? || Rails.env.test?)
    raise RedisClusterValidator::CrossSlotError, "Redis command #{result[:command_name]} arguments hash to different slots. See https://docs.gitlab.com/ee/development/redis.html#multi-key-commands"
  end

  increment_allowed_cross_slot_request_count if result[:allowed] && !result[:valid]

  result[:valid] || result[:allowed]
end

.storage_key ⇒ Object

TODO: To be used by gitlab.com/gitlab-com/gl-infra/scalability/-/issues/395 as a ‘label’ alias.



14
15
16
 
# File 'lib/gitlab/instrumentation/redis_base.rb', line 14

def storage_key
  self.name.demodulize.underscore
end

.write_bytes ⇒ Object 



66
67
68
 
# File 'lib/gitlab/instrumentation/redis_base.rb', line 66

def write_bytes
  ::RequestStore[write_bytes_key] || 0
end