kotovalexarian-likes-gitlab/gitlab-org--gitlab-foss
1
0
Fork 0
Code Releases Activity

Introduce missing Action concept

Browse source
This commit is contained in:
Pawel Chojnacki 2017-09-06 03:02:08 +02:00
parent c97dc61a9e
commit 6db3151fa1
4 changed files with 62 additions and 33 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

35
lib/gitlab/metrics/method_call.rb
View file

@ -4,26 +4,29 @@ module Gitlab
class MethodCall
attr_reader :real_time, :cpu_time, :call_count
# name - The full name of the method (including namespace) such as
# `User#sign_in`.
#
def self.call_real_duration_histogram
@call_real_duration_histogram ||= Gitlab::Metrics.histogram(:gitlab_method_call_real_duration_milliseconds,
'Method calls real duration',
{call_name: nil},
[1, 2, 5, 10, 20, 50, 100, 1000])
@call_real_duration_histogram ||= Gitlab::Metrics.histogram(
:gitlab_method_call_real_duration_seconds,
'Method calls real duration',
{ action: nil, call_name: nil },
[1000, 2000, 5000, 10000, 20000, 50000, 100000, 1000000]
)
end
def self.call_cpu_duration_histogram
@call_duration_histogram ||= Gitlab::Metrics.histogram(:gitlab_method_call_cpu_duration_milliseconds,
'Method calls cpu duration',
{call_name: nil},
[1, 2, 5, 10, 20, 50, 100, 1000])
@call_duration_histogram ||= Gitlab::Metrics.histogram(
:gitlab_method_call_cpu_duration_seconds,
'Method calls cpu duration',
{ action: nil, call_name: nil },
[1000, 2000, 5000, 10000, 20000, 50000, 100000, 1000000]
)
end
def initialize(name)
# name - The full name of the method (including namespace) such as
# `User#sign_in`.
#
def initialize(name, action)
@action = action
@name = name
@real_time = 0
@cpu_time = 0
@ -41,8 +44,8 @@ module Gitlab
@call_count += 1
if above_threshold?
self.class.call_real_duration_histogram.observe({ call_name: @name }, @real_time)
self.class.call_cpu_duration_histogram.observe({ call_name: @name }, @cpu_time)
self.class.call_real_duration_histogram.observe({ call_name: @name, action: @action }, @real_time)
self.class.call_cpu_duration_histogram.observe({ call_name: @name, action: @action }, @cpu_time)
end
retval

4
lib/gitlab/metrics/subscribers/active_record.rb
View file

@ -8,14 +8,14 @@ module Gitlab
def self.metric_sql_duration_seconds
@metric_sql_duration_seconds ||= Gitlab::Metrics.histogram(
:gitlab_sql_duration_seconds,
'SQL duration seconds',
'SQL time',
{},
[0.001, 0.002, 0.005, 0.01, 0.02, 0.05, 0.1, 0.500, 2.0, 10.0]
)
end
def sql(event)
self.class.metric_sql_duration_secodnds.observe({}, event.duration/1000.0)
self.class.metric_sql_duration_secodnds.observe({}, event.duration / 1000.0)
return unless current_transaction
current_transaction.increment(:sql_duration, event.duration, false)

44
lib/gitlab/metrics/subscribers/rails_cache.rb
View file

@ -6,54 +6,80 @@ module Gitlab
class RailsCache < ActiveSupport::Subscriber
attach_to :active_support
def self.metric_cache_duration_seconds
@metric_cache_duration_seconds ||= Gitlab::Metrics.histogram(
:gitlab_cache_duration_seconds,
'Cache access time',
{ action: nil, operation: nil },
[0.001, 0.002, 0.005, 0.01, 0.02, 0.05, 0.1, 0.500, 2.0, 10.0]
)
end
def self.metric_cache_read_hit_total
@metric_cache_read_hit_total ||= Gitlab::Metrics.counter(:gitlab_cache_read_hit_total, 'Cache read hit', { action: nil })
end
def self.metric_cache_read_miss_total
@metric_cache_read_miss_total ||= Gitlab::Metrics.counter(:gitlab_cache_read_miss_total, 'Cache read miss', { action: nil })
end
def cache_read(event)
increment(:cache_read, event.duration)
observe(:read, event.duration)
return unless current_transaction
return if event.payload[:super_operation] == :fetch
if event.payload[:hit]
self.class.metric_cache_read_hit_total.increment({ action: action })
current_transaction.increment(:cache_read_hit_count, 1)
else
self.class.metric_cache_read_miss_total.increment({ action: action })
current_transaction.increment(:cache_read_miss_count, 1)
end
end
def cache_write(event)
increment(:cache_write, event.duration)
observe(:write, event.duration)
end
def cache_delete(event)
increment(:cache_delete, event.duration)
observe(:delete, event.duration)
end
def cache_exist?(event)
increment(:cache_exists, event.duration)
observe(:exists, event.duration)
end
def cache_fetch_hit(event)
return unless current_transaction
self.class.metric_cache_read_hit_total.increment({ action: action })
current_transaction.increment(:cache_read_hit_count, 1)
end
def cache_generate(event)
return unless current_transaction
self.class.metric_cache_read_miss_total.increment({ action: action })
current_transaction.increment(:cache_read_miss_count, 1)
end
def increment(key, duration)
def observe(key, duration)
return unless current_transaction
current_transaction.increment(:cache_duration, duration)
current_transaction.increment(:cache_count, 1)
current_transaction.increment("#{key}_duration".to_sym, duration)
current_transaction.increment("#{key}_count".to_sym, 1)
metric_cache_duration_seconds.observe({ operation: key, action: action }, duration / 1000.1)
current_transaction.increment(:cache_duration, duration, false)
current_transaction.increment(:cache_count, 1, false)
current_transaction.increment("#{key}_duration".to_sym, duration, false)
current_transaction.increment("#{key}_count".to_sym, 1, false)
end
private
def action
current_transaction&.action
end
def current_transaction
Transaction.current
end

12
lib/gitlab/metrics/transaction.rb
View file

@ -43,8 +43,8 @@ module Gitlab
def self.metric_transaction_duration_seconds
@metric_transaction_duration_seconds ||= Gitlab::Metrics.histogram(
:gitlab_transaction_duration_seconds,
'Transaction duration seconds',
{},
'Transaction duration',
{ action: nil },
[0.001, 0.002, 0.005, 0.01, 0.02, 0.05, 0.1, 0.500, 2.0, 10.0]
)
end
@ -53,7 +53,7 @@ module Gitlab
@metric_transaction_allocated_memory_bytes ||= Gitlab::Metrics.histogram(
:gitlab_transaction_allocated_memory_bytes,
'Transaction allocated memory bytes',
{},
{ action: nil },
[500000, 1000000, 2000000, 5000000, 10000000, 20000000, 100000000]
)
end
@ -69,8 +69,8 @@ module Gitlab
@memory_after = System.memory_usage
@finished_at = System.monotonic_time
Transaction.metric_transaction_duration_seconds.observe({}, duration * 1000)
Transaction.metric_transaction_allocated_memory_bytes.observe({}, allocated_memory / 2 ^ 20)
Transaction.metric_transaction_duration_seconds.observe({ action: action }, duration * 1000)
Transaction.metric_transaction_allocated_memory_bytes.observe({ action: action }, allocated_memory / 2 ^ 20)
Thread.current[THREAD_KEY] = nil
end
@ -94,7 +94,7 @@ module Gitlab
# Returns a MethodCall object for the given name.
def method_call_for(name)
unless method = @methods[name]
@methods[name] = method = MethodCall.new(name)
@methods[name] = method = MethodCall.new(name, action)
end
method