fluent-plugin-cloudwatch-put-timestamp 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: df3cfc631ba9a373ab05582f82a5f1b256002562
+  data.tar.gz: 6e0692d11405e3cce5774af80fa75b77c16977db
+SHA512:
+  metadata.gz: 8a75016c5f2720893a4da6d3b52030860ebdb79cf849b9fcc77eb506d04e49a4e6a5ab7c3ff8023293b2def8c793fa6e9a9661dcfeca50d7665342629ed524bc
+  data.tar.gz: e982668c37b2ea834506072af62791732bc5ba188545d0fde135b022883ced021c5bb4a168b7c497eaf57e6ea738fd6a14a33abe1f11a632029161fee553eeb1

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/gemfiles/.bundle
+*.gemfile.lock

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 2.2.8
+  - 2.3.4
+  - 2.4.2
+before_install: gem install bundler

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 joker1007
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,203 @@
+# fluent-plugin-cloudwatch-put
+[![Build Status](https://travis-ci.org/joker1007/fluent-plugin-cloudwatch-put.svg?branch=master)](https://travis-ci.org/joker1007/fluent-plugin-cloudwatch-put)
+
+[Fluentd](http://fluentd.org/) output plugin to put metric data to AWS CloudWatch.
+
+This plugin for fluentd-0.14.x or later.
+
+## Installation
+
+### RubyGems
+
+```
+$ gem install fluent-plugin-cloudwatch-put
+```
+
+### Bundler
+
+Add following line to your Gemfile:
+
+```ruby
+gem "fluent-plugin-cloudwatch-put"
+```
+
+And then execute:
+
+```
+$ bundle
+```
+
+## Plugin helpers
+
+* inject
+
+* See also: Fluent::Plugin::Output
+
+## Configuration
+
+```
+<match cloudwatch.metric_name>
+  @type cloudwatch_put
+
+  <buffer tag, key1>
+    path cloudwatch.*.buffer
+
+    flush_interval 1m
+  </buffer>
+
+  aws_key_id "#{ENV["AWS_ACCESS_KEY_ID"]}"
+  aws_sec_key "#{ENV["AWS_SECRET_ACCESS_KEY"]}"
+
+  region ap-northeast-1
+
+  namespace "Dummy/Namespace"
+  metric_name ${tag[1]}
+  unit Count
+  value_key value
+
+  use_statistic_sets
+
+  <dimensions>
+    name method
+    value ${key1}
+  </dimensions>
+</match>
+```
+
+### namespace (string) (required)
+
+CloudWatch metric namespace (support placeholder)
+
+### metric_name (string) (required)
+
+CloudWatch metric name (support placeholder)
+
+### key_as_metric_name (bool) (optional)
+
+Use record key as metric name
+
+Default value: `false`
+
+### unit (string) (required)
+
+CloudWatch metric unit (support placeholder)
+
+### value_key (array\<string\>) (required)
+
+Use this key as metric value
+
+### storage_resolution (integer) (optional)
+
+Cloudwatch storage resolution
+
+Default value: `60`.
+
+### use_statistic_sets (bool) (optional)
+
+If this is true, aggregates record chunk before put metric
+
+
+### \<dimensions\> section (required) (multiple)
+
+#### name (string) (required)
+
+Dimension name (support placeholder)
+
+#### key (string) (optional)
+
+Use this key as dimension value. If use_statistic_sets is true, this param is not supported. Use `value`
+
+#### value (string) (optional)
+
+Use static value as dimension value (support placeholder)
+
+
+### \<buffer\> section (optional) (multiple)
+
+#### chunk_limit_size (optional)
+
+Default value: `30720`.
+
+#### chunk_limit_records (optional)
+
+Default value: `20`.
+
+## Configuration for Authentication
+
+### aws_key_id (string) (optional)
+
+AWS access key id
+
+### aws_sec_key (string) (optional)
+
+AWS secret key.
+
+### region (string) (optional)
+
+region name
+
+Default value: `us-east-1`.
+
+### proxy_uri (string) (optional)
+
+URI of proxy environment
+
+### \<assume_role_credentials\> section (optional) (single)
+
+#### role_arn (string) (required)
+
+The Amazon Resource Name (ARN) of the role to assume
+
+#### role_session_name (string) (required)
+
+An identifier for the assumed role session
+
+#### policy (string) (optional)
+
+An IAM policy in JSON format
+
+#### duration_seconds (integer) (optional)
+
+The duration, in seconds, of the role session (900-3600)
+
+#### external_id (string) (optional)
+
+A unique identifier that is used by third parties when assuming roles in their customers' accounts.
+
+### \<instance_profile_credentials\> section (optional) (single)
+
+#### retries (integer) (optional)
+
+Number of times to retry when retrieving credentials
+
+#### ip_address (string) (optional)
+
+IP address (default:169.254.169.254)
+
+#### port (integer) (optional)
+
+Port number (default:80)
+
+#### http_open_timeout (float) (optional)
+
+Number of seconds to wait for the connection to open
+
+#### http_read_timeout (float) (optional)
+
+Number of seconds to wait for one block to be read
+
+### \<shared_credentials\> section (optional) (single)
+
+#### path (string) (optional)
+
+Path to the shared file. (default: $HOME/.aws/credentials)
+
+#### profile_name (string) (optional)
+
+Profile name. Default to 'default' or ENV['AWS_PROFILE']
+
+## Copyright
+
+* Copyright(c) 2017- joker1007
+* License
+  * MIT License

data/Rakefile

@@ -0,0 +1,13 @@
+require "bundler"
+Bundler::GemHelper.install_tasks
+
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs.push("lib", "test")
+  t.test_files = FileList["test/**/test_*.rb"]
+  t.verbose = true
+  t.warning = true
+end
+
+task default: [:test]

data/fluent-plugin-cloudwatch-put.gemspec

@@ -0,0 +1,29 @@
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name    = "fluent-plugin-cloudwatch-put-timestamp"
+  spec.version = "0.1.1"
+  spec.authors = [""]
+
+  spec.summary       = %q{Cloudwatch put metric plugin for fluentd.}
+  spec.description   = %q{Cloudwatch put metric plugin for fluentd.}
+  spec.homepage      = "https://github.com/jmmgr/fluent-plugin-cloudwatch-put"
+  spec.license       = "MIT"
+
+  test_files, files  = `git ls-files -z`.split("\x0").partition do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.files         = files
+  spec.executables   = files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = test_files
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.14"
+  spec.add_development_dependency "rake", "~> 12.0"
+  spec.add_development_dependency "test-unit", "~> 3.0"
+  spec.add_development_dependency "test-unit-rr"
+
+  spec.add_runtime_dependency "fluentd", [">= 0.14.10", "< 2"]
+  spec.add_runtime_dependency "aws-sdk-cloudwatch", "~> 1"
+end

data/lib/fluent/plugin/out_cloudwatch_put.rb

@@ -0,0 +1,269 @@
+require "fluent/plugin/output"
+require "aws-sdk-cloudwatch"
+
+module Fluent
+  module Plugin
+    class CloudWatchPutOutput < Fluent::Plugin::Output
+      Fluent::Plugin.register_output("cloudwatch_put", self)
+
+      helpers :inject
+
+      # Credential Configs from fluent-plugin-s3
+      # Apache License,  version 2.0
+      desc "AWS access key id"
+      config_param :aws_key_id, :string, default: nil, secret: true
+      desc "AWS secret key."
+      config_param :aws_sec_key, :string, default: nil, secret: true
+      config_section :assume_role_credentials, multi: false do
+        desc "The Amazon Resource Name (ARN) of the role to assume"
+        config_param :role_arn, :string, secret: true
+        desc "An identifier for the assumed role session"
+        config_param :role_session_name, :string
+        desc "An IAM policy in JSON format"
+        config_param :policy, :string, default: nil
+        desc "The duration, in seconds, of the role session (900-3600)"
+        config_param :duration_seconds, :integer, default: nil
+        desc "A unique identifier that is used by third parties when assuming roles in their customers' accounts."
+        config_param :external_id, :string, default: nil, secret: true
+      end
+      config_section :instance_profile_credentials, multi: false do
+        desc "Number of times to retry when retrieving credentials"
+        config_param :retries, :integer, default: nil
+        desc "IP address (default:169.254.169.254)"
+        config_param :ip_address, :string, default: nil
+        desc "Port number (default:80)"
+        config_param :port, :integer, default: nil
+        desc "Number of seconds to wait for the connection to open"
+        config_param :http_open_timeout, :float, default: nil
+        desc "Number of seconds to wait for one block to be read"
+        config_param :http_read_timeout, :float, default: nil
+        # config_param :delay, :integer or :proc, :default => nil
+        # config_param :http_degub_output, :io, :default => nil
+      end
+      config_section :shared_credentials, multi: false do
+        desc "Path to the shared file. (default: $HOME/.aws/credentials)"
+        config_param :path, :string, default: nil
+        desc "Profile name. Default to 'default' or ENV['AWS_PROFILE']"
+        config_param :profile_name, :string, default: nil
+      end
+
+      desc "region name"
+      config_param :region, :string, default: ENV["AWS_REGION"] || "us-east-1"
+
+      desc "URI of proxy environment"
+      config_param :proxy_uri, :string, default: nil
+
+      desc "CloudWatch metric namespace (support placeholder)"
+      config_param :namespace, :string
+      desc "CloudWatch metric name (support placeholder)"
+      config_param :metric_name, :string, default: nil
+      desc "Use keyname as metric name"
+      config_param :key_as_metric_name, :bool, default: false
+      desc "CloudWatch metric unit (support placeholder)"
+      config_param :unit, :string
+
+      desc "Definition of dimension"
+      config_section :dimensions, multi: true, required: false do
+        desc "Dimension name (support placeholder)"
+        config_param :name, :string
+        #desc "Use this key as dimension value. If use_statistic_sets is true, this param is not supported. Use `value`"
+        #config_param :key, :string, default: nil
+        desc "Use static value as dimension value (support placeholder)"
+        config_param :value, :string, default: nil
+      end
+
+      desc "Use this key as metric value"
+      config_param :value_key, :array, value_type: :string
+
+      desc "Cloudwatch storage resolution"
+      config_param :storage_resolution, :integer, default: 60
+
+      #desc "If this is true, aggregates record chunk before put metric"
+      #config_param :use_statistic_sets, :bool, default: false
+
+      config_section :buffer do
+        config_set_default :chunk_limit_size, 30 * 1024
+        config_set_default :chunk_limit_records, 20 # max record size of metric_data payload
+      end
+
+      attr_reader :cloudwatch
+
+      def configure(conf)
+        super
+
+        unless !!@metric_name ^ @key_as_metric_name
+          raise Fluent::ConfigError, "'Either 'metric_name'' or 'key_as_metric_name' must be set"
+        end
+
+        @send_all_key = false
+        if @value_key.size == 1 && @value_key[0] == "*"
+          @send_all_key = true
+        end
+
+        placeholder_params = "namespace=#{@namespace}/metric_name=#{@metric_name}/unit=#{@unit}"
+        placeholder_validate!(:cloudwatch_put, placeholder_params)
+      end
+
+      def multi_workers_ready?
+        true
+      end
+
+      def start
+        super
+
+        options = setup_credentials
+        options[:region] = @region if @region
+        options[:http_proxy] = @proxy_uri if @proxy_uri
+        log.on_trace do
+          options[:http_wire_trace] = true
+          options[:logger] = log
+        end
+
+        @cloudwatch = Aws::CloudWatch::Client.new(options)
+      end
+
+      def write(chunk)
+#        if @use_statistic_sets
+#          metric_data = build_statistic_metric_data(chunk)
+#        else
+         metric_data = build_metric_data(chunk)
+#        end
+
+        namespace = extract_placeholders(@namespace, chunk.metadata)
+        log.debug "Put metric to #{namespace}, count=#{metric_data.size}"
+        log.on_trace do
+          log.trace metric_data.to_json
+        end
+        @cloudwatch.put_metric_data({
+          namespace: namespace,
+          metric_data: metric_data,
+        })
+      end
+
+      private
+
+      def base_metric_data(meta)
+        {
+          unit: extract_placeholders(@unit, meta),
+          storage_resolution: @storage_resolution,
+        }
+      end
+
+      def build_metric_data(chunk)
+        meta = chunk.metadata
+        metric_data = []
+        chunk.msgpack_each do |(timestamp, record)|
+          record.each do |k, v|
+            next unless @value_key.include?(k) || @send_all_key
+            timestamp_aws = record['timestamp'] || timestamp
+            metric_name = @key_as_metric_name ? k : extract_placeholders(@metric_name, meta)
+
+            unless timestamp_aws.is_a? Fixnum
+              log.error "Invalid timestamp for metric_name #{metric_name} timestamp #{timestamp_aws} needs to be a number"
+              timestamp_aws = timestamp
+            end
+
+            metric_data << {
+              metric_name: metric_name,
+              unit: extract_placeholders(@unit, meta),
+              storage_resolution: @storage_resolution,
+              dimensions: record['dimensions'].map do |dk, dv|
+                {
+                  name: dk,
+                  value: dv
+                }
+              end,
+              value: v.to_f,
+              timestamp: Time.at(timestamp_aws)
+            }
+          end
+        end
+        metric_data
+      end
+
+  #    def build_statistic_metric_data(chunk)
+  #      meta = chunk.metadata
+  #      values = []
+  #      timestamps = []
+  #      chunk.msgpack_each do |(timestamp, record)|
+  #        record.each do |k, v|
+  #          next unless @value_key.include?(k) || @send_all_key
+  #          values << v.to_f
+  #        end
+  #        timestamps << timestamp
+  #      end
+
+  #      [
+  #        base_metric_data(meta).merge({
+  #          metric_name: extract_placeholders(@metric_name, meta),
+  #          dimensions: @dimensions.map { |d|
+  #            {
+  #              name: extract_placeholders(d.name, meta),
+  #              value: extract_placeholders(d.value, meta),
+  #            }
+  #          }.select { |d| !d[:name].empty? },
+  #          statistic_values: {
+  #            sample_count: values.size,
+  #            sum: values.inject(&:+),
+  #            minimum: values.min,
+  #            maximum: values.max,
+  #          },
+  #          timestamp: Time.at(timestamps.max)
+  #        })
+  #      ]
+  #    end
+
+      # Credential Configs from fluent-plugin-s3
+      # Apache License,  version 2.0
+      def setup_credentials
+        options = {}
+        credentials_options = {}
+        case
+        when @aws_key_id && @aws_sec_key
+          options[:access_key_id] = @aws_key_id
+          options[:secret_access_key] = @aws_sec_key
+        when @assume_role_credentials
+          c = @assume_role_credentials
+          credentials_options[:role_arn] = c.role_arn
+          credentials_options[:role_session_name] = c.role_session_name
+          credentials_options[:policy] = c.policy if c.policy
+          credentials_options[:duration_seconds] = c.duration_seconds if c.duration_seconds
+          credentials_options[:external_id] = c.external_id if c.external_id
+          if @region
+            credentials_options[:client] = Aws::STS::Client.new(region: @region)
+          end
+          options[:credentials] = Aws::AssumeRoleCredentials.new(credentials_options)
+        when @instance_profile_credentials
+          c = @instance_profile_credentials
+          credentials_options[:retries] = c.retries if c.retries
+          credentials_options[:ip_address] = c.ip_address if c.ip_address
+          credentials_options[:port] = c.port if c.port
+          credentials_options[:http_open_timeout] = c.http_open_timeout if c.http_open_timeout
+          credentials_options[:http_read_timeout] = c.http_read_timeout if c.http_read_timeout
+          if ENV["AWS_CONTAINER_CREDENTIALS_RELATIVE_URI"]
+            options[:credentials] = Aws::ECSCredentials.new(credentials_options)
+          else
+            options[:credentials] = Aws::InstanceProfileCredentials.new(credentials_options)
+          end
+        when @shared_credentials
+          c = @shared_credentials
+          credentials_options[:path] = c.path if c.path
+          credentials_options[:profile_name] = c.profile_name if c.profile_name
+          options[:credentials] = Aws::SharedCredentials.new(credentials_options)
+        when @aws_iam_retries
+          log.warn("'aws_iam_retries' parameter is deprecated. Use 'instance_profile_credentials' instead")
+          credentials_options[:retries] = @aws_iam_retries
+          if ENV["AWS_CONTAINER_CREDENTIALS_RELATIVE_URI"]
+            options[:credentials] = Aws::ECSCredentials.new(credentials_options)
+          else
+            options[:credentials] = Aws::InstanceProfileCredentials.new(credentials_options)
+          end
+        else
+          # Use default credentials
+          # See http://docs.aws.amazon.com/sdkforruby/api/Aws/S3/Client.html
+        end
+        options
+      end
+    end
+  end
+end

data/test/helper.rb

@@ -0,0 +1,9 @@
+$LOAD_PATH.unshift(File.expand_path("../../", __FILE__))
+require "test-unit"
+require "test/unit/rr"
+require "fluent/test"
+require "fluent/test/driver/output"
+require "fluent/test/helpers"
+
+Test::Unit::TestCase.include(Fluent::Test::Helpers)
+Test::Unit::TestCase.extend(Fluent::Test::Helpers)

data/test/plugin/test_out_cloudwatch_put.rb

@@ -0,0 +1,334 @@
+require "helper"
+require "fluent/plugin/out_cloudwatch_put.rb"
+
+class CloudWatchPutOutputTest < Test::Unit::TestCase
+  setup do
+    Fluent::Test.setup
+  end
+
+  DEFAULT_CONF = %q{
+    region ap-northeast-1
+    namespace Test
+    metric_name MetricName
+    unit Count
+
+    <dimensions>
+      name dim1
+      key key1
+    </dimensions>
+
+    <dimensions>
+      name dim2
+      key key2
+    </dimensions>
+
+    value_key key3
+
+    aws_key_id dummy
+    aws_sec_key dummy
+  }
+
+  test "configure" do
+    d = create_driver
+    assert { d.instance.buffer.chunk_limit_size == 30 * 1024 }
+    assert { d.instance.dimensions.size == 2 }
+    assert { d.instance.dimensions[0].name == "dim1" }
+    assert { d.instance.dimensions[1].name == "dim2" }
+  end
+
+  test "write" do
+    d = create_driver
+    now = Time.now.to_i
+
+    d.instance.start
+
+    mock(d.instance.cloudwatch).put_metric_data({
+      namespace: "Test",
+      metric_data: [
+        {
+          metric_name: "MetricName",
+          dimensions: [
+            {
+              name: "dim1",
+              value: "val1",
+            },
+            {
+              name: "dim2",
+              value: "val2",
+            },
+          ],
+          timestamp: Time.at(now),
+          value: 1.0,
+          unit: "Count",
+          storage_resolution: 60,
+        },
+        {
+          metric_name: "MetricName",
+          dimensions: [
+            {
+              name: "dim1",
+              value: "val1",
+            },
+            {
+              name: "dim2",
+              value: "val2",
+            },
+          ],
+          timestamp: Time.at(now),
+          value: 2.0,
+          unit: "Count",
+          storage_resolution: 60,
+        },
+        {
+          metric_name: "MetricName",
+          dimensions: [
+            {
+              name: "dim1",
+              value: "val1",
+            },
+            {
+              name: "dim2",
+              value: "val2",
+            },
+          ],
+          timestamp: Time.at(now),
+          value: 3.0,
+          unit: "Count",
+          storage_resolution: 60,
+        },
+      ]
+    })
+
+    d.run do
+      d.feed('tag', now, {"key1" => "val1", "key2" => "val2", "key3" => 1})
+      d.feed('tag', now, {"key1" => "val1", "key2" => "val2", "key3" => 2})
+      d.feed('tag', now, {"key1" => "val1", "key2" => "val2", "key3" => 3})
+    end
+  end
+
+  test "write (multi value_key)" do
+    conf = %q{
+      region ap-northeast-1
+      namespace Test
+      key_as_metric_name true
+      unit Count
+
+      <dimensions>
+        name dim1
+        value dim_value1
+      </dimensions>
+
+      <dimensions>
+        name dim2
+        value dim_value2
+      </dimensions>
+
+      value_key key1, key2, key3
+
+      aws_key_id dummy
+      aws_sec_key dummy
+    }
+    d = create_driver(conf)
+    now = Time.now.to_i
+
+    d.instance.start
+
+    mock(d.instance.cloudwatch).put_metric_data({
+      namespace: "Test",
+      metric_data: [
+        {
+          metric_name: "key1",
+          dimensions: [
+            {
+              name: "dim1",
+              value: "dim_value1",
+            },
+            {
+              name: "dim2",
+              value: "dim_value2",
+            },
+          ],
+          timestamp: Time.at(now),
+          value: 1.0,
+          unit: "Count",
+          storage_resolution: 60,
+        },
+        {
+          metric_name: "key2",
+          dimensions: [
+            {
+              name: "dim1",
+              value: "dim_value1",
+            },
+            {
+              name: "dim2",
+              value: "dim_value2",
+            },
+          ],
+          timestamp: Time.at(now),
+          value: 2.0,
+          unit: "Count",
+          storage_resolution: 60,
+        },
+        {
+          metric_name: "key3",
+          dimensions: [
+            {
+              name: "dim1",
+              value: "dim_value1",
+            },
+            {
+              name: "dim2",
+              value: "dim_value2",
+            },
+          ],
+          timestamp: Time.at(now),
+          value: 3.0,
+          unit: "Count",
+          storage_resolution: 60,
+        },
+      ]
+    })
+
+    d.run do
+      d.feed('tag', now, {"key1" => 1, "key2" => 2, "key3" => 3})
+    end
+  end
+
+  test "write (use_statistic_sets)" do
+    conf = %q{
+      region ap-northeast-1
+      namespace Test
+      metric_name MetricName
+      unit Count
+
+      use_statistic_sets
+
+      <dimensions>
+        name dim1
+        value dim_value1
+      </dimensions>
+
+      <dimensions>
+        name dim2
+        value dim_value2
+      </dimensions>
+
+      value_key key3
+
+      aws_key_id dummy
+      aws_sec_key dummy
+    }
+    d = create_driver(conf)
+    now = Time.now.to_i
+
+    d.instance.start
+
+    mock(d.instance.cloudwatch).put_metric_data({
+      namespace: "Test",
+      metric_data: [
+        {
+          metric_name: "MetricName",
+          dimensions: [
+            {
+              name: "dim1",
+              value: "dim_value1",
+            },
+            {
+              name: "dim2",
+              value: "dim_value2",
+            },
+          ],
+          timestamp: Time.at(now),
+          statistic_values: {
+            sample_count: 3,
+            sum: 6.0,
+            minimum: 1.0,
+            maximum: 3.0,
+          },
+          unit: "Count",
+          storage_resolution: 60,
+        },
+      ]
+    })
+
+    d.run do
+      d.feed('tag', now, {"key1" => "val1", "key2" => "val2", "key3" => 1})
+      d.feed('tag', now, {"key1" => "val1", "key2" => "val2", "key3" => 2})
+      d.feed('tag', now, {"key1" => "val1", "key2" => "val2", "key3" => 3})
+    end
+  end
+
+  test "write (use_statistic_sets) (placeholder)" do
+    conf = %q{
+      <buffer tag, key1, key2>
+      </buffer>
+
+      region ap-northeast-1
+      namespace ${tag[0]}
+      metric_name ${tag[1]}
+      unit Count
+
+      use_statistic_sets
+
+      <dimensions>
+        name dim1
+        value ${key1}
+      </dimensions>
+
+      <dimensions>
+        name dim2
+        value ${key2}
+      </dimensions>
+
+      value_key key3
+
+      aws_key_id dummy
+      aws_sec_key dummy
+    }
+    d = create_driver(conf)
+    now = Time.now.to_i
+
+    d.instance.start
+
+    mock(d.instance.cloudwatch).put_metric_data({
+      namespace: "namespace",
+      metric_data: [
+        {
+          metric_name: "metric_name",
+          dimensions: [
+            {
+              name: "dim1",
+              value: "val1",
+            },
+            {
+              name: "dim2",
+              value: "val2",
+            },
+          ],
+          timestamp: Time.at(now),
+          statistic_values: {
+            sample_count: 3,
+            sum: 6.0,
+            minimum: 1.0,
+            maximum: 3.0,
+          },
+          unit: "Count",
+          storage_resolution: 60,
+        },
+      ]
+    })
+
+    d.run do
+      d.feed('namespace.metric_name', now, {"key1" => "val1", "key2" => "val2", "key3" => 1})
+      d.feed('namespace.metric_name', now, {"key1" => "val1", "key2" => "val2", "key3" => 2})
+      d.feed('namespace.metric_name', now, {"key1" => "val1", "key2" => "val2", "key3" => 3})
+    end
+  end
+
+  private
+
+  def create_driver(conf = DEFAULT_CONF)
+    Fluent::Test::Driver::Output.new(Fluent::Plugin::CloudWatchPutOutput).configure(conf)
+  end
+end

metadata

@@ -0,0 +1,145 @@
+--- !ruby/object:Gem::Specification
+name: fluent-plugin-cloudwatch-put-timestamp
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- ''
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-11-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: test-unit-rr
+  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: fluentd
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.14.10
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.14.10
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-cloudwatch
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+description: Cloudwatch put metric plugin for fluentd.
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- fluent-plugin-cloudwatch-put.gemspec
+- lib/fluent/plugin/out_cloudwatch_put.rb
+- test/helper.rb
+- test/plugin/test_out_cloudwatch_put.rb
+homepage: https://github.com/jmmgr/fluent-plugin-cloudwatch-put
+licenses:
+- MIT
+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: Cloudwatch put metric plugin for fluentd.
+test_files:
+- test/helper.rb
+- test/plugin/test_out_cloudwatch_put.rb