fluent-plugin-docker-metrics-v2 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: efa365192704ccf603a7d9f856fc64ead0954757
+  data.tar.gz: 16bfa49d533f6a7c01341287ddc8e25dfd59e29f
+SHA512:
+  metadata.gz: 2925f9ee57a4df7e2866aede03e712bcfb8eed1b917655828e4a8423ccad0e8a71d16e8c643b61db3399d3b9e62801045e4e336f62600adb00c2ce9a0aad1a54
+  data.tar.gz: 33a83e4927af7306d70d7f6d2e30aee8929cc919cc7bd315d4ae05479d79857bbe0e8d4e415bb2ddb440fd7345584746f5a7c18c9122120e6cd043048c4b1a40

data/CHANGELOG

@@ -0,0 +1,7 @@
+## v0.0.2 2014/11/22
+
+- Change the output format. The "source" field is deprecated. Instead, it has "hostname", "id", and "container".
+
+## v0.0.1 2014/06/27
+
+- Initial release

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/README.md

@@ -0,0 +1,41 @@
+# Fluentd Docker Metrics Input Plugin
+
+This is a [Fluentd](http://www.fluentd.org) plugin to collect Docker metrics periodically.
+
+## How it works
+
+It's assumed to run on the host server. It periodically runs Docker Remote API calls to fetch container IDs and looks at `/sys/fs/cgroups/<metric_type>/docker/<container_id>/`
+for relevant stats. You can say this is an implementation of the metric collection strategy outlined in [this blog post](http://blog.docker.com/2013/10/gathering-lxc-docker-containers-metrics/).
+
+## Installing
+
+to be uploaded on Rubygems
+
+## Example config
+
+```
+<source>
+  type docker_metrics
+  stats_interval 1m
+</source>
+```
+
+## Parameters
+
+* **stats_interval**: how often to poll Docker containers for stats. The default is every minute.
+* **cgroup_path**: The path to cgroups pseudofiles. The default is `sys/fs/cgroup`.
+* **tag_prefix**: The tag prefix. The default value is "docker"
+
+## Example output
+
+```
+2014-11-22 17:48:26 +0000 docker.blkio.io_queued: {"key":"blkio_io_queued_total","value":0,"type":"counter","hostname":"precise64","id":"24f5fb3bfc429e88aa3dbacd704667899dc496067cedcfa58dd84da42e7cb3cf","name":"/world"}
+2014-11-22 17:48:26 +0000 docker.blkio.sectors: {"key":"blkio_sectors","value":136,"type":"counter","hostname":"precise64","id":"24f5fb3bfc429e88aa3dbacd704667899dc496067cedcfa58dd84da42e7cb3cf","name":"/world"}
+```
+
+In particular, each event is a key-value pair of individual metrics. Also, it has
+
+- `hostname` is the hostname of the Docker host
+- `id` is the ID of the container
+- `name` is the descriptive name of the container (a la `docker inspect --format '{{ .Names }}'`)
+

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |test|
+  test.libs << "test" << "lib"
+  test.pattern = 'test/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test

data/fluent-plugin-docker-metrics.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name          = "fluent-plugin-docker-metrics-v2"
+  spec.version       = "0.0.1"
+  spec.authors       = ["orr"]
+  spec.email         = ["orr@innovid.com"]
+  spec.summary       = %q{Fluentd plugin to collect Docker container metrics}
+  spec.homepage      = "https://github.com/kiyoto/fluent-plugin-docker-metrics"
+  spec.license       = "Apache-2.0"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "fakefs"
+  spec.add_development_dependency "test-unit", "~> 3.1"
+  spec.add_development_dependency "minitest", "~> 5.8"
+  spec.add_runtime_dependency "fluentd"
+  spec.add_runtime_dependency "docker-api"
+end

data/lib/fluent/plugin/in_docker_metrics.rb

@@ -0,0 +1,175 @@
+require 'fluent/input'
+
+module Fluent
+  class DockerMetricsInput < Input
+    Plugin.register_input('docker_metrics', self)
+
+    # Define `router` method of v0.12 to support v0.10 or earlier
+    unless method_defined?(:router)
+      define_method("router") { Engine }
+    end
+
+    config_param :cgroup_path, :string, :default => '/sys/fs/cgroup'
+    config_param :stats_interval, :time, :default => 60 # every minute
+    config_param :tag_prefix, :string, :default => "docker"
+    config_param :container_ids, :array, :default => nil # mainly for testing
+
+    def initialize
+      super
+      require 'socket'
+      require 'docker'
+      @hostname = Socket.gethostname
+      @with_systemd = File.exists?("#{@cgroup_path}/systemd")
+    end
+
+    def configure(conf)
+      super
+
+    end
+
+    def start
+      @loop = Coolio::Loop.new
+      tw = TimerWatcher.new(@stats_interval, true, @log, &method(:get_metrics))
+      tw.attach(@loop)
+      @thread = Thread.new(&method(:run))
+    end
+    def run
+      @loop.run
+    rescue
+      log.error "unexpected error", :error=>$!.to_s
+      log.error_backtrace
+    end
+
+    # Metrics collection methods
+    def get_metrics
+      ids = @container_ids || list_container_ids
+      ids.each do |id, name|
+        emit_container_metric(id, name, 'memory', 'memory.stat') 
+        emit_container_metric(id, name, 'cpuacct', 'cpuacct.stat') 
+        emit_container_metric(id, name, 'blkio', 'blkio.io_serviced') 
+        emit_container_metric(id, name, 'blkio', 'blkio.io_service_bytes') 
+        emit_container_metric(id, name, 'blkio', 'blkio.io_queued') 
+        emit_container_metric(id, name, 'blkio', 'blkio.sectors') 
+      end
+    end
+
+    def list_container_ids
+      Docker::Container.all.map do |container|
+        [container.id, container.info["Names"].first]
+      end
+    end
+
+    def emit_container_metric(id, name, metric_type, metric_filename, opts = {})
+
+      if @with_systemd
+        path = "#{@cgroup_path}/#{metric_type}/system.slice/docker-#{id}.scope/#{metric_filename}"
+      else
+        path = "#{@cgroup_path}/#{metric_type}/docker/#{id}/#{metric_filename}"
+      end
+
+      if File.exists?(path)
+        # the order of these two if's matters
+        if metric_filename == 'blkio.sectors'
+          parser = BlkioSectorsParser.new(path, metric_filename.gsub('.', '_'))
+        elsif metric_type == 'blkio'
+          parser = BlkioStatsParser.new(path, metric_filename.gsub('.', '_'))
+        else
+          parser = KeyValueStatsParser.new(path, metric_filename.gsub('.', '_'))
+        end
+        time = Engine.now
+        tag = "#{@tag_prefix}.#{metric_filename}"
+        mes = MultiEventStream.new
+        parser.parse_each_line do |data|
+          next if not data
+          # TODO: address this more elegantly
+          if data['key'] =~ /^(?:cpuacct|blkio|memory_stat_pg)/
+            data['type'] = 'counter'
+          else
+            data['type'] = 'gauge'
+          end
+          data["hostname"] = @hostname
+          data["id"] = id
+          data["name"] = name.sub(/^\//, '')
+          mes.add(time, data)
+        end
+        router.emit_stream(tag, mes)
+      else
+        nil
+      end
+    end
+
+    def shutdown
+      @loop.stop
+      @thread.join
+    end
+
+    class TimerWatcher < Coolio::TimerWatcher
+
+      def initialize(interval, repeat, log, &callback)
+        @callback = callback
+        @log = log
+        super(interval, repeat)
+      end
+      def on_timer
+        @callback.call
+      rescue
+        @log.error $!.to_s
+        @log.error_backtrace
+      end
+    end
+
+    class CGroupStatsParser
+      def initialize(path, metric_type)
+        raise ConfigError if not File.exists?(path)
+        @path = path
+        @metric_type = metric_type
+      end
+
+      def parse_line(line)
+      end
+
+      def parse_each_line(&block)
+        File.new(@path).each_line do |line|
+          block.call(parse_line(line))
+        end
+      end
+    end
+
+    class KeyValueStatsParser < CGroupStatsParser
+      def parse_line(line)
+        k, v = line.split(/\s+/, 2)
+        if k and v
+          { 'key' => @metric_type + "_" + k, 'value' => v.to_i }
+        else
+          nil
+        end
+      end
+    end
+
+    class BlkioStatsParser < CGroupStatsParser
+      BlkioLineRegexp = /^(?<major>\d+):(?<minor>\d+) (?<key>[^ ]+) (?<value>\d+)/
+      
+      def parse_line(line)
+        m = BlkioLineRegexp.match(line)
+        if m
+          { 'key' => @metric_type + "_" + m["key"].downcase, 'value' => m["value"].to_i }
+        else
+          nil
+        end
+      end
+    end
+
+    class BlkioSectorsParser < CGroupStatsParser
+      BlkioSectorsLineRegexp = /^(?<major>\d+):(?<minor>\d+) (?<value>\d+)/
+
+      def parse_line(line)
+        m = BlkioSectorsLineRegexp.match(line)
+        if m
+          { 'key' => @metric_type, 'value' => m["value"].to_i }
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/test/data/blkio.io_queued

@@ -0,0 +1,6 @@
+8:0 Read 0
+8:0 Write 0
+8:0 Sync 0
+8:0 Async 0
+8:0 Total 0
+Total 0

data/test/data/blkio.io_service_bytes

@@ -0,0 +1,6 @@
+8:0 Read 14970880
+8:0 Write 4096
+8:0 Sync 14974976
+8:0 Async 0
+8:0 Total 14974976
+Total 14974976

data/test/data/blkio.io_serviced

@@ -0,0 +1,6 @@
+8:0 Read 822
+8:0 Write 1
+8:0 Sync 823
+8:0 Async 0
+8:0 Total 823
+Total 823

data/test/data/blkio.sectors

@@ -0,0 +1 @@
+8:0 816

data/test/data/cpuacct.stat

@@ -0,0 +1,2 @@
+user 0
+system 0

data/test/data/memory.stat

@@ -0,0 +1,28 @@
+cache 32768
+rss 471040
+mapped_file 0
+pgpgin 293
+pgpgout 170
+swap 0
+pgfault 1254
+pgmajfault 0
+inactive_anon 20480
+active_anon 483328
+inactive_file 0
+active_file 0
+unevictable 0
+hierarchical_memory_limit 9223372036854775807
+hierarchical_memsw_limit 9223372036854775807
+total_cache 32768
+total_rss 471040
+total_mapped_file 0
+total_pgpgin 293
+total_pgpgout 170
+total_swap 0
+total_pgfault 1254
+total_pgmajfault 0
+total_inactive_anon 20480
+total_active_anon 483328
+total_inactive_file 0
+total_active_file 0
+total_unevictable 0

data/test/test_in_docker_metrics.rb

@@ -0,0 +1,136 @@
+require 'fluent/test'
+require 'fluent/plugin/in_docker_metrics'
+require 'fakefs/safe'
+require 'minitest/autorun'
+
+class TestDockerMetricsInput < Minitest::Test
+  METRICS = [
+      ['memory', 'memory.stat'], 
+      ['cpuacct', 'cpuacct.stat'], 
+      ['blkio', 'blkio.io_serviced'], 
+      ['blkio', 'blkio.io_service_bytes'], 
+      ['blkio', 'blkio.io_queued'],
+      ['blkio', 'blkio.sectors']
+    ]
+
+  def setup
+    Fluent::Test.setup
+    @container_id = 'sadais1337hacker'
+    @container_name = 'sample_container'
+    @mock_metrics = read_mock_metrics
+    FakeFS.activate!
+    setup_proc_files
+  end
+
+  def read_mock_metrics
+    metrics = {}
+    METRICS.each do |_, file|
+      p = "#{File.dirname(File.expand_path(__FILE__))}/data/#{file}"
+      if not File.exists?(p)
+        raise IOError, p
+      end
+      metrics[file] = File.new(p).read 
+    end
+    metrics
+  end
+
+  def setup_proc_files
+    METRICS.each do |type, file|
+      path = "/sys/fs/cgroup/#{type}/docker/#{@container_id}"
+      FileUtils.mkdir_p(path)
+      fh = File.new("#{path}/#{file}", "w")
+      fh.write(@mock_metrics[file])
+      fh.close
+    end
+  end
+
+  def create_driver
+    Fluent::Test::InputTestDriver.new(Fluent::DockerMetricsInput).configure(%[
+      container_ids [["#{@container_id}", "#{@container_name}"]]
+      stats_interval 5s
+    ])
+  end
+
+  def test_outputs
+    d = create_driver
+    d.run do
+      sleep 2
+    end
+
+    emits = d.emits
+    check_metric_type(emits, 'memory.stat', [
+        {"key"=>"memory_stat_cache", "value"=>32768},
+        {"key"=>"memory_stat_rss", "value"=>471040},
+        {"key"=>"memory_stat_mapped_file", "value"=>0},
+        {"key"=>"memory_stat_pgpgin", "value"=>293},
+        {"key"=>"memory_stat_pgpgout", "value"=>170},
+        {"key"=>"memory_stat_swap", "value"=>0},
+        {"key"=>"memory_stat_pgfault", "value"=>1254},
+        {"key"=>"memory_stat_pgmajfault", "value"=>0},
+        {"key"=>"memory_stat_inactive_anon", "value"=>20480},
+        {"key"=>"memory_stat_active_anon", "value"=>483328},
+        {"key"=>"memory_stat_inactive_file", "value"=>0},
+        {"key"=>"memory_stat_active_file", "value"=>0},
+        {"key"=>"memory_stat_unevictable", "value"=>0},
+        {"key"=>"memory_stat_hierarchical_memory_limit", "value"=>9223372036854775807},
+        {"key"=>"memory_stat_hierarchical_memsw_limit", "value"=>9223372036854775807},
+        {"key"=>"memory_stat_total_cache", "value"=>32768},
+        {"key"=>"memory_stat_total_rss", "value"=>471040},
+        {"key"=>"memory_stat_total_mapped_file", "value"=>0},
+        {"key"=>"memory_stat_total_pgpgin", "value"=>293},
+        {"key"=>"memory_stat_total_pgpgout", "value"=>170},
+        {"key"=>"memory_stat_total_swap", "value"=>0},
+        {"key"=>"memory_stat_total_pgfault", "value"=>1254},
+        {"key"=>"memory_stat_total_pgmajfault", "value"=>0},
+        {"key"=>"memory_stat_total_inactive_anon", "value"=>20480},
+        {"key"=>"memory_stat_total_active_anon", "value"=>483328},
+        {"key"=>"memory_stat_total_inactive_file", "value"=>0},
+        {"key"=>"memory_stat_total_active_file", "value"=>0},
+        {"key"=>"memory_stat_total_unevictable", "value"=>0}
+      ])
+    check_metric_type(emits, 'cpuacct.stat', [
+        {"key"=>"cpuacct_stat_user", "value"=>0},
+        {"key"=>"cpuacct_stat_system", "value"=>0}
+      ])
+    check_metric_type(emits, 'blkio.io_queued', [
+        {"key"=>"blkio_io_queued_read", "value"=>0},
+        {"key"=>"blkio_io_queued_write", "value"=>0},
+        {"key"=>"blkio_io_queued_sync", "value"=>0},
+        {"key"=>"blkio_io_queued_async", "value"=>0},
+        {"key"=>"blkio_io_queued_total", "value"=>0}
+      ])
+    check_metric_type(emits, 'blkio.io_serviced', [
+        {"key"=>"blkio_io_serviced_read", "value"=>822},
+        {"key"=>"blkio_io_serviced_write", "value"=>1},
+        {"key"=>"blkio_io_serviced_sync", "value"=>823},
+        {"key"=>"blkio_io_serviced_async", "value"=>0},
+        {"key"=>"blkio_io_serviced_total", "value"=>823}
+      ])
+    check_metric_type(emits, 'blkio.sectors', [
+        {"key"=>"blkio_sectors", "value"=>816}
+      ])
+  end
+
+  def check_metric_type(emits, type, records)
+    stats = emits.select do |tag, time, record| tag == "docker.#{type}" end
+    assert_equal records.length, stats.length, "Mismatch for #{type}"
+    assert_equal @container_id, emits.first[2]["id"]
+    assert_equal @container_name, emits.first[2]["name"]
+    records.each do |record|
+      find_metric(stats, record)
+    end
+  end
+
+  def find_metric(emits, expected_record)
+    match = emits.select do |_, _, record|
+      record["key"] == expected_record["key"] &&
+      record["value"] == expected_record["value"]
+    end
+
+    assert_equal 1, match.length, "Didn't find #{expected_record.to_json} among #{emits.to_json}"
+  end
+
+  def teardown
+    FakeFS.deactivate!
+  end
+end 

metadata

@@ -0,0 +1,162 @@
+--- !ruby/object:Gem::Specification
+name: fluent-plugin-docker-metrics-v2
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- orr
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-11-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fakefs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.8'
+- !ruby/object:Gem::Dependency
+  name: fluentd
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: docker-api
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- orr@innovid.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG
+- Gemfile
+- README.md
+- Rakefile
+- fluent-plugin-docker-metrics.gemspec
+- lib/fluent/plugin/in_docker_metrics.rb
+- test/data/blkio.io_queued
+- test/data/blkio.io_service_bytes
+- test/data/blkio.io_serviced
+- test/data/blkio.sectors
+- test/data/cpuacct.stat
+- test/data/memory.stat
+- test/test_in_docker_metrics.rb
+homepage: https://github.com/kiyoto/fluent-plugin-docker-metrics
+licenses:
+- Apache-2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Fluentd plugin to collect Docker container metrics
+test_files:
+- test/data/blkio.io_queued
+- test/data/blkio.io_service_bytes
+- test/data/blkio.io_serviced
+- test/data/blkio.sectors
+- test/data/cpuacct.stat
+- test/data/memory.stat
+- test/test_in_docker_metrics.rb