BigW Consortium Gitlab

sampler.rb 3.48 KB
Newer Older
1 2 3 4 5 6 7 8 9
module Gitlab
  module Metrics
    # Class that sends certain metrics to InfluxDB at a specific interval.
    #
    # This class is used to gather statistics that can't be directly associated
    # with a transaction such as system memory usage, garbage collection
    # statistics, etc.
    class Sampler
      # interval - The sampling interval in seconds.
10
      def initialize(interval = Metrics.settings[:sample_interval])
11 12 13 14 15 16 17
        interval_half = interval.to_f / 2

        @interval       = interval
        @interval_steps = (-interval_half..interval_half).step(0.1).to_a
        @last_step      = nil

        @metrics = []
18 19 20

        @last_minor_gc = Delta.new(GC.stat[:minor_gc_count])
        @last_major_gc = Delta.new(GC.stat[:major_gc_count])
21 22 23 24 25 26

        if Gitlab::Metrics.mri?
          require 'allocations'

          Allocations.start
        end
27 28 29 30 31 32 33
      end

      def start
        Thread.new do
          Thread.current.abort_on_exception = true

          loop do
34
            sleep(sleep_interval)
35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53

            sample
          end
        end
      end

      def sample
        sample_memory_usage
        sample_file_descriptors
        sample_objects
        sample_gc

        flush
      ensure
        GC::Profiler.clear
        @metrics.clear
      end

      def flush
54
        Metrics.submit_metrics(@metrics.map(&:to_hash))
55 56 57
      end

      def sample_memory_usage
58
        add_metric('memory_usage', value: System.memory_usage)
59 60 61
      end

      def sample_file_descriptors
62
        add_metric('file_descriptors', value: System.file_descriptor_count)
63 64
      end

65 66 67 68
      if Metrics.mri?
        def sample_objects
          sample = Allocations.to_hash
          counts = sample.each_with_object({}) do |(klass, count), hash|
69 70 71 72 73
            name = klass.name

            next unless name

            hash[name] = count
74 75 76 77 78 79
          end

          # Symbols aren't allocated so we'll need to add those manually.
          counts['Symbol'] = Symbol.all_symbols.length

          counts.each do |name, count|
80
            add_metric('object_counts', { count: count }, type: name)
81 82 83 84
          end
        end
      else
        def sample_objects
85
        end
86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101
      end

      def sample_gc
        time  = GC::Profiler.total_time * 1000.0
        stats = GC.stat.merge(total_time: time)

        # We want the difference of GC runs compared to the last sample, not the
        # total amount since the process started.
        stats[:minor_gc_count] =
          @last_minor_gc.compared_with(stats[:minor_gc_count])

        stats[:major_gc_count] =
          @last_major_gc.compared_with(stats[:major_gc_count])

        stats[:count] = stats[:minor_gc_count] + stats[:major_gc_count]

102 103 104 105 106 107 108 109 110 111 112
        add_metric('gc_statistics', stats)
      end

      def add_metric(series, values, tags = {})
        prefix = sidekiq? ? 'sidekiq_' : 'rails_'

        @metrics << Metric.new("#{prefix}#{series}", values, tags)
      end

      def sidekiq?
        Sidekiq.server?
113
      end
114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130

      # Returns the sleep interval with a random adjustment.
      #
      # The random adjustment is put in place to ensure we:
      #
      # 1. Don't generate samples at the exact same interval every time (thus
      #    potentially missing anything that happens in between samples).
      # 2. Don't sample data at the same interval two times in a row.
      def sleep_interval
        while step = @interval_steps.sample
          if step != @last_step
            @last_step = step

            return @interval + @last_step
          end
        end
      end
131 132 133
    end
  end
end