139 lines
4 KiB
Ruby
139 lines
4 KiB
Ruby
# frozen_string_literal: true
|
|
|
|
module Gitlab
|
|
module Metrics
|
|
# Class for storing metrics information of a single transaction.
|
|
class Transaction
|
|
include Gitlab::Metrics::Methods
|
|
|
|
# base labels shared among all transactions
|
|
BASE_LABELS = { controller: nil, action: nil }.freeze
|
|
# labels that potentially contain sensitive information and will be filtered
|
|
FILTERED_LABELS = [:branch, :path].freeze
|
|
|
|
THREAD_KEY = :_gitlab_metrics_transaction
|
|
|
|
# The series to store events (e.g. Git pushes) in.
|
|
EVENT_SERIES = 'events'
|
|
|
|
attr_reader :tags, :method
|
|
|
|
def self.current
|
|
Thread.current[THREAD_KEY]
|
|
end
|
|
|
|
def initialize
|
|
@methods = {}
|
|
|
|
@started_at = nil
|
|
@finished_at = nil
|
|
|
|
@tags = {}
|
|
|
|
@memory_before = 0
|
|
@memory_after = 0
|
|
end
|
|
|
|
def duration
|
|
@finished_at ? (@finished_at - @started_at) : 0.0
|
|
end
|
|
|
|
def thread_cpu_duration
|
|
System.thread_cpu_duration(@thread_cputime_start)
|
|
end
|
|
|
|
def allocated_memory
|
|
@memory_after - @memory_before
|
|
end
|
|
|
|
def run
|
|
Thread.current[THREAD_KEY] = self
|
|
|
|
@memory_before = System.memory_usage_rss
|
|
@started_at = System.monotonic_time
|
|
@thread_cputime_start = System.thread_cpu_time
|
|
|
|
yield
|
|
ensure
|
|
@memory_after = System.memory_usage_rss
|
|
@finished_at = System.monotonic_time
|
|
|
|
self.class.gitlab_transaction_cputime_seconds.observe(labels, thread_cpu_duration)
|
|
self.class.gitlab_transaction_duration_seconds.observe(labels, duration)
|
|
self.class.gitlab_transaction_allocated_memory_bytes.observe(labels, allocated_memory * 1024.0)
|
|
|
|
Thread.current[THREAD_KEY] = nil
|
|
end
|
|
|
|
# Tracks a business level event
|
|
#
|
|
# Business level events including events such as Git pushes, Emails being
|
|
# sent, etc.
|
|
#
|
|
# event_name - The name of the event (e.g. "git_push").
|
|
# tags - A set of tags to attach to the event.
|
|
def add_event(event_name, tags = {})
|
|
filtered_tags = filter_tags(tags)
|
|
self.class.transaction_metric(event_name, :counter, prefix: 'event_', tags: filtered_tags).increment(filtered_tags.merge(labels))
|
|
end
|
|
|
|
# Returns a MethodCall object for the given name.
|
|
def method_call_for(name, module_name, method_name)
|
|
unless method = @methods[name]
|
|
@methods[name] = method = MethodCall.new(name, module_name, method_name, self)
|
|
end
|
|
|
|
method
|
|
end
|
|
|
|
def increment(name, value, use_prometheus = true)
|
|
self.class.transaction_metric(name, :counter).increment(labels, value) if use_prometheus
|
|
end
|
|
|
|
def set(name, value, use_prometheus = true)
|
|
self.class.transaction_metric(name, :gauge).set(labels, value) if use_prometheus
|
|
end
|
|
|
|
def labels
|
|
BASE_LABELS
|
|
end
|
|
|
|
define_histogram :gitlab_transaction_cputime_seconds do
|
|
docstring 'Transaction thread cputime'
|
|
base_labels BASE_LABELS
|
|
buckets [0.1, 0.25, 0.5, 1.0, 2.5, 5.0]
|
|
end
|
|
|
|
define_histogram :gitlab_transaction_duration_seconds do
|
|
docstring 'Transaction duration'
|
|
base_labels BASE_LABELS
|
|
buckets [0.1, 0.25, 0.5, 1.0, 2.5, 5.0]
|
|
end
|
|
|
|
define_histogram :gitlab_transaction_allocated_memory_bytes do
|
|
docstring 'Transaction allocated memory bytes'
|
|
base_labels BASE_LABELS
|
|
buckets [100, 1000, 10000, 100000, 1000000, 10000000]
|
|
end
|
|
|
|
def self.transaction_metric(name, type, prefix: nil, tags: {})
|
|
metric_name = "gitlab_transaction_#{prefix}#{name}_total".to_sym
|
|
fetch_metric(type, metric_name) do
|
|
docstring "Transaction #{prefix}#{name} #{type}"
|
|
base_labels tags.merge(BASE_LABELS)
|
|
|
|
if type == :gauge
|
|
multiprocess_mode :livesum
|
|
end
|
|
end
|
|
end
|
|
|
|
private
|
|
|
|
def filter_tags(tags)
|
|
tags.without(*FILTERED_LABELS)
|
|
end
|
|
end
|
|
end
|
|
end
|