BigW Consortium Gitlab

Skip to content

G
gitlab-ce
Commit 534f6b11 by Pawel Chojnacki
Options

Tests for Web transaction and remove simple transacton

parent 929418da
Showing with 41 additions and 272 deletions
lib/gitlab/metrics/base_transaction.rb
......@@ -2,7 +2,8 @@ module Gitlab
module Metrics
# Class for storing metrics information of a single transaction.
class BaseTransaction
BASE_LABELS = { }.freeze
# base labels shared among all transactions
BASE_LABELS = { controller: nil, action: nil }.freeze
THREAD_KEY = :_gitlab_metrics_transaction
......@@ -15,9 +16,7 @@ module Gitlab
Thread.current[THREAD_KEY]
end
# action - A String describing the action performed, usually the class
# plus method name.
def initialize(env)
def initialize
@metrics = []
@methods = {}
......@@ -26,7 +25,6 @@ module Gitlab
@values = Hash.new(0)
@tags = {}
@env = env
@memory_before = 0
@memory_after = 0
......@@ -40,10 +38,6 @@ module Gitlab
@memory_after - @memory_before
end
def labels
{}
end
def run
Thread.current[THREAD_KEY] = self
......@@ -120,7 +114,6 @@ module Gitlab
submit_hashes = submit.map do |metric|
hash = metric.to_hash
hash[:tags][:action] ||= action if action && !metric.event?
hash
......@@ -129,7 +122,16 @@ module Gitlab
Metrics.submit_metrics(submit_hashes)
end
private
def labels
BASE_LABELS
end
# returns string describing the action performed, usually the class plus method name.
def action
"#{labels[:controller]}##{labels[:action]}" if labels && !labels.empty?
end
protected
def self.metric_transaction_duration_seconds
@metric_transaction_duration_seconds ||= Gitlab::Metrics.histogram(
......
lib/gitlab/metrics/sidekiq_middleware.rb
......@@ -5,7 +5,7 @@ module Gitlab
# This middleware is intended to be used as a server-side middleware.
class SidekiqMiddleware
def call(worker, message, queue)
trans = Transaction.new("#{worker.class.name}#perform")
trans = SidekiqTransaction.new(worker.class)
begin
# Old gitlad-shell messages don't provide enqueued_at/created_at attributes
......
lib/gitlab/metrics/sidekiq_transaction.rb 0 → 100644
module Gitlab
module Metrics
class SidekiqTransaction
def initialize(worker_class)
@worker_class = worker_class
end
protected
def labels
{ controller: worker.class.name, action: 'perform' }
end
end
end
end
lib/gitlab/metrics/transaction.rb deleted 100644 → 0
module Gitlab
module Metrics
# Class for storing metrics information of a single transaction.
class Transaction
BASE_LABELS = { controller: nil, action: nil }.freeze
CONTROLLER_KEY = 'action_controller.instance'.freeze
ENDPOINT_KEY = 'api.endpoint'.freeze
CONTENT_TYPES = {
'text/html' => :html,
'text/plain' => :txt,
'application/json' => :json,
'text/js' => :js,
'application/atom+xml' => :atom,
'image/png' => :png,
'image/jpeg' => :jpeg,
'image/gif' => :gif,
'image/svg+xml' => :svg
}.freeze
THREAD_KEY = :_gitlab_metrics_transaction
# The series to store events (e.g. Git pushes) in.
EVENT_SERIES = 'events'.freeze
attr_reader :tags, :values, :method, :metrics
def self.current
Thread.current[THREAD_KEY]
end
# action - A String describing the action performed, usually the class
# plus method name.
def initialize(env)
@metrics = []
@methods = {}
@started_at = nil
@finished_at = nil
@values = Hash.new(0)
@tags = {}
@env = env
@memory_before = 0
@memory_after = 0
end
def duration
@finished_at ? (@finished_at - @started_at) : 0.0
end
def allocated_memory
@memory_after - @memory_before
end
def action
"#{labels[:controller]}##{labels[:action]}" if labels && !labels.empty?
end
def labels
return @labels if @labels
# memoize transaction labels only source env variables were present
@labels = if @env[CONTROLLER_KEY]
labels_from_controller || {}
elsif @env[ENDPOINT_KEY]
labels_from_endpoint || {}
end
@labels || {}
end
def run
Thread.current[THREAD_KEY] = self
@memory_before = System.memory_usage
@started_at = System.monotonic_time
yield
ensure
@memory_after = System.memory_usage
@finished_at = System.monotonic_time
Transaction.metric_transaction_duration_seconds.observe(labels, duration * 1000)
Transaction.metric_transaction_allocated_memory_bytes.observe(labels, allocated_memory * 1024.0)
Thread.current[THREAD_KEY] = nil
end
def add_metric(series, values, tags = {})
@metrics << Metric.new("#{Metrics.series_prefix}#{series}", values, tags)
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 = {})
self.class.metric_event_counter(event_name, tags).increment(tags.merge(labels))
@metrics << Metric.new(EVENT_SERIES, { count: 1 }, tags.merge(event: event_name), :event)
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.metric_transaction_counter(name).increment(labels, value) if use_prometheus
@values[name] += value
end
def set(name, value, use_prometheus = true)
self.class.metric_transaction_gauge(name).set(labels, value) if use_prometheus
@values[name] = value
end
def finish
track_self
submit
end
def track_self
values = { duration: duration, allocated_memory: allocated_memory }
@values.each do |name, value|
values[name] = value
end
add_metric('transactions', values, @tags)
end
def submit
submit = @metrics.dup
@methods.each do |name, method|
submit << method.to_metric if method.above_threshold?
end
submit_hashes = submit.map do |metric|
hash = metric.to_hash
hash[:tags][:action] ||= action if action && !metric.event?
hash
end
Metrics.submit_metrics(submit_hashes)
end
private
def self.metric_transaction_duration_seconds
@metric_transaction_duration_seconds ||= Gitlab::Metrics.histogram(
:gitlab_transaction_duration_seconds,
'Transaction duration',
BASE_LABELS,
[0.001, 0.002, 0.005, 0.01, 0.02, 0.05, 0.1, 0.500, 2.0, 10.0]
)
end
def self.metric_transaction_allocated_memory_bytes
@metric_transaction_allocated_memory_bytes ||= Gitlab::Metrics.histogram(
:gitlab_transaction_allocated_memory_bytes,
'Transaction allocated memory bytes',
BASE_LABELS,
[1000, 10000, 20000, 500000, 1000000, 2000000, 5000000, 10000000, 20000000, 100000000]
)
end
def self.metric_event_counter(event_name, tags)
@metric_event_counters ||= {}
@metric_event_counters[event_name] ||= Gitlab::Metrics.counter(
"gitlab_transaction_event_#{event_name}_total".to_sym,
"Transaction event #{event_name} counter",
tags.merge(BASE_LABELS)
)
end
def self.metric_transaction_counter(name)
@metric_transaction_counters ||= {}
@metric_transaction_counters[name] ||= Gitlab::Metrics.counter(
"gitlab_transaction_#{name}_total".to_sym, "Transaction #{name} counter", BASE_LABELS
)
end
def self.metric_transaction_gauge(name)
@metric_transaction_gauges ||= {}
@metric_transaction_gauges[name] ||= Gitlab::Metrics.gauge(
"gitlab_transaction_#{name}".to_sym, "Transaction gauge #{name}", BASE_LABELS, :livesum
)
end
def labels_from_controller
controller = @env[CONTROLLER_KEY]
action = "#{controller.action_name}"
suffix = CONTENT_TYPES[controller.content_type]
if suffix && suffix != :html
action += ".#{suffix}"
end
{ controller: controller.class.name, action: action }
end
def labels_from_endpoint
endpoint = @env[ENDPOINT_KEY]
begin
route = endpoint.route
rescue
# endpoint.route is calling env[Grape::Env::GRAPE_ROUTING_ARGS][:route_info]
# but env[Grape::Env::GRAPE_ROUTING_ARGS] is nil in the case of a 405 response
# so we're rescuing exceptions and bailing out
end
if route
path = endpoint_paths_cache[route.request_method][route.path]
{ controller: 'Grape', action: "#{route.request_method} #{path}" }
end
end
def endpoint_paths_cache
@endpoint_paths_cache ||= Hash.new do |hash, http_method|
hash[http_method] = Hash.new do |inner_hash, raw_path|
inner_hash[raw_path] = endpoint_instrumentable_path(raw_path)
end
end
end
def endpoint_instrumentable_path(raw_path)
raw_path.sub('(.:format)', '').sub('/:version', '')
end
end
end
end
lib/gitlab/metrics/web_transaction.rb
module Gitlab
module Metrics
# Class for storing metrics information of a single transaction.
class WebTransaction
BASE_LABELS = { controller: nil, action: nil }.freeze
class WebTransaction < BaseTransaction
CONTROLLER_KEY = 'action_controller.instance'.freeze
ENDPOINT_KEY = 'api.endpoint'.freeze
......@@ -18,10 +16,9 @@ module Gitlab
'image/svg+xml' => :svg
}.freeze
attr_reader :tags, :values, :method, :metrics
def action
"#{labels[:controller]}##{labels[:action]}" if labels && !labels.empty?
def initialize(env)
super()
@env = env
end
def labels
......
spec/lib/gitlab/metrics/instrumentation_spec.rb
......@@ -2,7 +2,7 @@ require 'spec_helper'
describe Gitlab::Metrics::Instrumentation do
let(:env) { {} }
let(:transaction) { Gitlab::Metrics::Transaction.new(env) }
let(:transaction) { Gitlab::Metrics::WebTransaction.new(env) }
before do
@dummy = Class.new do
......
spec/lib/gitlab/metrics/subscribers/action_view_spec.rb
......@@ -2,7 +2,7 @@ require 'spec_helper'
describe Gitlab::Metrics::Subscribers::ActionView do
let(:env) { {} }
let(:transaction) { Gitlab::Metrics::Transaction.new(env) }
let(:transaction) { Gitlab::Metrics::WebTransaction.new(env) }
let(:subscriber) { described_class.new }
......
spec/lib/gitlab/metrics/subscribers/active_record_spec.rb
......@@ -2,7 +2,7 @@ require 'spec_helper'
describe Gitlab::Metrics::Subscribers::ActiveRecord do
let(:env) { {} }
let(:transaction) { Gitlab::Metrics::Transaction.new(env) }
let(:transaction) { Gitlab::Metrics::WebTransaction.new(env) }
let(:subscriber) { described_class.new }
let(:event) do
......
spec/lib/gitlab/metrics/transaction_spec.rb → spec/lib/gitlab/metrics/web_transaction_spec.rb
require 'spec_helper'
describe Gitlab::Metrics::Transaction do
describe Gitlab::Metrics::WebTransaction do
let(:env) { {} }
let(:transaction) { described_class.new(env) }
......
spec/lib/gitlab/metrics_spec.rb
......@@ -115,7 +115,7 @@ describe Gitlab::Metrics do
end
context 'with a transaction' do
let(:transaction) { Gitlab::Metrics::Transaction.new({}) }
let(:transaction) { Gitlab::Metrics::WebTransaction.new({}) }
before do
allow(described_class).to receive(:current_transaction)
......@@ -155,7 +155,7 @@ describe Gitlab::Metrics do
context 'with a transaction' do
it 'sets the action of a transaction' do
trans = Gitlab::Metrics::Transaction.new({})
trans = Gitlab::Metrics::WebTransaction.new({})
expect(described_class).to receive(:current_transaction)
.and_return(trans)
......@@ -185,7 +185,7 @@ describe Gitlab::Metrics do
context 'with a transaction' do
it 'adds an event' do
transaction = Gitlab::Metrics::Transaction.new({})
transaction = Gitlab::Metrics::WebTransaction.new({})
expect(transaction).to receive(:add_event).with(:meow)
......
spec/lib/gitlab/middleware/rails_queue_duration_spec.rb
......@@ -4,7 +4,7 @@ describe Gitlab::Middleware::RailsQueueDuration do
let(:app) { double(:app) }
let(:middleware) { described_class.new(app) }
let(:env) { {} }
let(:transaction) { Gitlab::Metrics::Transaction.new(env) }
let(:transaction) { Gitlab::Metrics::WebTransaction.new(env) }
before do
expect(app).to receive(:call).with(env).and_return('yay')
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment