fluentd 1.2.0.pre1 → 1.2.0

data/lib/fluent/plugin_helper.rb

@@ -26,6 +26,7 @@ require 'fluent/plugin_helper/inject'
 require 'fluent/plugin_helper/extract'
 require 'fluent/plugin_helper/socket'
 require 'fluent/plugin_helper/server'
+require 'fluent/plugin_helper/counter'
 require 'fluent/plugin_helper/retry_state'
 require 'fluent/plugin_helper/record_accessor'
 require 'fluent/plugin_helper/compat_parameters'

data/lib/fluent/plugin_helper/counter.rb

@@ -0,0 +1,51 @@
+#
+# Fluentd
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+
+require 'fluent/plugin'
+require 'fluent/counter/client'
+
+module Fluent
+  module PluginHelper
+    module Counter
+      def counter_client_create(scope:, loop: Coolio::Loop.new)
+        client_conf = system_config.counter_client
+        raise Fluent::ConfigError, '<counter_client> is required in <system>' unless client_conf
+        counter_client = Fluent::Counter::Client.new(loop, port: client_conf.port, host: client_conf.host, log: log, timeout: client_conf.timeout)
+        counter_client.start
+        counter_client.establish(scope)
+        @_counter_client = counter_client
+        counter_client
+      end
+
+      attr_reader :_counter_client
+
+      def initialize
+        super
+        @_counter_client = nil
+      end
+
+      def stop
+        super
+        @_counter_client.stop
+      end
+
+      def terminate
+        @_counter_client = nil
+        super
+      end
+    end
+  end
+end

data/lib/fluent/plugin_helper/retry_state.rb

@@ -165,18 +165,26 @@ module Fluent
         end
 
         def calc_interval(num)
-          # make it infinite if calculated "interval" is too big
-          interval = @constant_factor.to_f * (@backoff_base ** (num - 1))
-          if interval.finite?
-            if @max_interval && interval > @max_interval
-              @max_interval
+          interval = raw_interval(num - 1)
+          if @max_interval && interval > @max_interval
+            @max_interval
+          else
+            if interval.finite?
+              interval
             else
+              # Calculate previous finite value to avoid inf related errors. If this re-computing is heavy, use cache.
+              until interval.finite?
+                num -= 1
+                interval = raw_interval(num - 1)
+              end
               interval
             end
-          else
-            interval
           end
         end
+
+        def raw_interval(num)
+          @constant_factor.to_f * (@backoff_base ** (num))
+        end
       end
 
       class PeriodicRetry < RetryStateMachine

data/lib/fluent/plugin_helper/server.rb

@@ -717,6 +717,9 @@ module Fluent
             end
           rescue IO::WaitReadable, IO::WaitWritable
             # ignore and return with doing nothing
+          rescue OpenSSL::SSL::SSLError => e
+            @log.warn "close socket due to unexpected ssl error: #{e}"
+            close rescue nil
           end
 
           def on_writable

data/lib/fluent/supervisor.rb

@@ -17,6 +17,7 @@
 require 'fileutils'
 
 require 'fluent/config'
+require 'fluent/counter'
 require 'fluent/env'
 require 'fluent/engine'
 require 'fluent/error'
@@ -41,6 +42,8 @@ module Fluent
   module ServerModule
     def before_run
       @start_time = Time.now
+      @rpc_server = nil
+      @counter = nil
 
       if config[:rpc_endpoint]
         @rpc_endpoint = config[:rpc_endpoint]
@@ -54,6 +57,10 @@ module Fluent
         install_windows_event_handler
       end
 
+      if counter = config[:counter_server]
+        run_counter_server(counter)
+      end
+
       socket_manager_path = ServerEngine::SocketManager::Server.generate_path
       ServerEngine::SocketManager::Server.open(socket_manager_path)
       ENV['SERVERENGINE_SOCKETMANAGER_PATH'] = socket_manager_path.to_s
@@ -61,6 +68,7 @@ module Fluent
 
     def after_run
       stop_rpc_server if @rpc_endpoint
+      stop_counter_server if @counter
       Fluent::Supervisor.cleanup_resources
     end
 
@@ -126,6 +134,18 @@ module Fluent
       @rpc_server.shutdown
     end
 
+    def run_counter_server(counter_conf)
+      @counter = Fluent::Counter::Server.new(
+        counter_conf.scope,
+        {host: counter_conf.bind, port: counter_conf.port, log: $log, path: counter_conf.backup_path}
+      )
+      @counter.start
+    end
+
+    def stop_counter_server
+      @counter.stop
+    end
+
     def install_supervisor_signal_handlers
       trap :HUP do
         $log.debug "fluentd supervisor process get SIGHUP"
@@ -160,7 +180,11 @@ module Fluent
 
     def supervisor_sigusr1_handler
       if log = config[:logger_initializer]
-        log.reopen!
+        # Creating new thread due to mutex can't lock
+        # in main thread during trap context
+        Thread.new {
+          log.reopen!
+        }.run
       end
 
       if config[:worker_pid]
@@ -249,6 +273,7 @@ module Fluent
       log_rotate_size = params['log_rotate_size']
       rpc_endpoint = system_config.rpc_endpoint
       enable_get_dump = system_config.enable_get_dump
+      counter_server = system_config.counter_server
 
       log_opts = {suppress_repeated_stacktrace: suppress_repeated_stacktrace}
       logger_initializer = Supervisor::LoggerInitializer.new(
@@ -290,6 +315,7 @@ module Fluent
           suppress_repeated_stacktrace: suppress_repeated_stacktrace,
           daemonize: daemonize,
           rpc_endpoint: rpc_endpoint,
+          counter_server: counter_server,
           enable_get_dump: enable_get_dump,
           windows_daemon_cmdline: [ServerEngine.ruby_bin_path,
                                    File.join(File.dirname(__FILE__), 'daemon.rb'),
@@ -663,14 +689,13 @@ module Fluent
     end
 
     def flush_buffer
-      $log.debug "fluentd main process get SIGUSR1"
-      $log.info "force flushing buffered events"
-      @log.reopen!
-
       # Creating new thread due to mutex can't lock
       # in main thread during trap context
       Thread.new {
         begin
+          $log.debug "fluentd main process get SIGUSR1"
+          $log.info "force flushing buffered events"
+          @log.reopen!
           Fluent::Engine.flush!
           $log.debug "flushing thread: flushed"
         rescue Exception => e

data/lib/fluent/system_config.rb

@@ -26,7 +26,7 @@ module Fluent
       :suppress_repeated_stacktrace, :emit_error_log_interval, :suppress_config_dump,
       :log_event_verbose,
       :without_source, :rpc_endpoint, :enable_get_dump, :process_name,
-      :file_permission, :dir_permission,
+      :file_permission, :dir_permission, :counter_server, :counter_client,
     ]
 
     config_param :workers,   :integer, default: 1
@@ -51,6 +51,28 @@ module Fluent
       config_param :time_format, :string, default: '%Y-%m-%d %H:%M:%S %z'
     end
 
+    config_section :counter_server, multi: false do
+      desc 'scope name of counter server'
+      config_param :scope, :string
+
+      desc 'the port of counter server to listen to'
+      config_param :port, :integer, default: nil
+      desc 'the bind address of counter server to listen to'
+      config_param :bind, :string, default: nil
+
+      desc 'backup file path of counter values'
+      config_param :backup_path, :string
+    end
+
+    config_section :counter_client, multi: false do
+      desc 'the port of counter server'
+      config_param :port, :integer, default: nil
+      desc 'the IP address or hostname of counter server'
+      config_param :host, :string
+      desc 'the timeout of each operation'
+      config_param :timeout, :time, default: nil
+    end
+
     def self.create(conf)
       systems = conf.elements(name: 'system')
       return SystemConfig.new if systems.empty?
@@ -98,7 +120,7 @@ module Fluent
       supervisor.instance_eval {
         SYSTEM_CONFIG_PARAMETERS.each do |param|
           case param
-          when :rpc_endpoint, :enable_get_dump, :process_name, :file_permission, :dir_permission
+          when :rpc_endpoint, :enable_get_dump, :process_name, :file_permission, :dir_permission, :counter_server, :counter_client
             next # doesn't exist in command line options
           when :emit_error_log_interval
             system.emit_error_log_interval = @suppress_interval if @suppress_interval
@@ -136,6 +158,8 @@ module Fluent
             instance_variable_set("@#{param}", param_value)
           end
         end
+        #@counter_server = system.counter_server unless system.counter_server.nil?
+        #@counter_client = system.counter_client unless system.counter_client.nil?
       }
     end
 

data/lib/fluent/version.rb

@@ -16,6 +16,6 @@
 
 module Fluent
 
-  VERSION = '1.2.0.pre1'
+  VERSION = '1.2.0'
 
 end

data/test/counter/test_client.rb

@@ -0,0 +1,549 @@
+require_relative '../helper'
+require 'fluent/counter/client'
+require 'fluent/counter/store'
+require 'fluent/counter/server'
+require 'flexmock/test_unit'
+require 'timecop'
+
+class CounterClientTest < ::Test::Unit::TestCase
+  TEST_ADDR = '127.0.0.1'
+  TEST_PORT = '8277'
+
+  setup do
+    # timecop isn't compatible with EventTime
+    t = Time.parse('2016-09-22 16:59:59 +0900')
+    Timecop.freeze(t)
+    @now = Fluent::EventTime.now
+
+    @options = {
+      addr: TEST_ADDR,
+      port: TEST_PORT,
+      log: $log,
+    }
+
+    @server_name = 'server1'
+    @scope = "worker1\tplugin1"
+    @loop = Coolio::Loop.new
+    @server = Fluent::Counter::Server.new(@server_name, @options).start
+    @client = Fluent::Counter::Client.new(@loop, @options).start
+  end
+
+  teardown do
+    Timecop.return
+    @server.stop
+    @client.stop
+  end
+
+  test 'Callable API' do
+    [:establish, :init, :delete, :inc, :reset, :get].each do |m|
+      assert_true @client.respond_to?(m)
+    end
+  end
+
+  sub_test_case 'on_message' do
+    setup do
+      @future = flexmock('future')
+      @client.instance_variable_set(:@responses, { 1 => @future })
+    end
+
+    test 'call a set method to a corresponding object' do
+      @future.should_receive(:set).once.with(Hash)
+      @client.send(:on_message, { 'id' => 1 })
+    end
+
+    test "output a warning log when passed id doesn't exist" do
+      data = { 'id' => 2 }
+      mock($log).warn("Receiving missing id data: #{data}")
+      @client.send(:on_message, data)
+    end
+  end
+
+  def extract_value_from_server(server, scope, name)
+    store = server.instance_variable_get(:@store).instance_variable_get(:@storage).instance_variable_get(:@store)
+    key = Fluent::Counter::Store.gen_key(scope, name)
+    store[key]
+  end
+
+  sub_test_case 'establish' do
+    test 'establish a scope' do
+      @client.establish(@scope)
+      assert_equal "#{@server_name}\t#{@scope}", @client.instance_variable_get(:@scope)
+    end
+
+    data(
+      empty: '',
+      invalid_string: '_scope',
+      invalid_string2: 'Scope'
+    )
+    test 'raise an error when passed scope is invalid' do |scope|
+      assert_raise do
+        @client.establish(scope)
+      end
+    end
+  end
+
+  sub_test_case 'init' do
+    setup do
+      @client.instance_variable_set(:@scope, @scope)
+    end
+
+    data(
+      numeric_type: [
+        { name: 'key', reset_interval: 20, type: 'numeric' }, 0
+      ],
+      float_type: [
+        { name: 'key', reset_interval: 20, type: 'float' }, 0.0
+      ],
+      integer_type: [
+        { name: 'key', reset_interval: 20, type: 'integer' }, 0
+      ]
+    )
+    test 'create a value' do |(param, initial_value)|
+      assert_nil extract_value_from_server(@server, @scope, param[:name])
+
+      response = @client.init(param).get
+      data = response.data.first
+
+      assert_nil response.errors
+      assert_equal param[:name], data['name']
+      assert_equal param[:reset_interval], data['reset_interval']
+      assert_equal param[:type], data['type']
+      assert_equal initial_value, data['current']
+      assert_equal initial_value, data['total']
+
+      v = extract_value_from_server(@server, @scope, param[:name])
+      assert_equal param[:name], v['name']
+      assert_equal param[:reset_interval], v['reset_interval']
+      assert_equal param[:type], v['type']
+      assert_equal initial_value, v['total']
+      assert_equal initial_value, v['current']
+    end
+
+    test 'raise an error when @scope is nil' do
+      @client.instance_variable_set(:@scope, nil)
+      assert_raise 'Call `establish` method to get a `scope` before calling this method' do
+        @client.init(name: 'key1', reset_interval: 10).get
+      end
+    end
+
+    data(
+      already_exist_key: [
+        { name: 'key1', reset_interval: 10 },
+        { 'code' => 'invalid_params', 'message' => "worker1\tplugin1\tkey1 already exists in counter" }
+      ],
+      missing_name: [
+        { reset_interval: 10 },
+        { 'code' => 'invalid_params', 'message' => '`name` is required' },
+      ],
+      missing_reset_interval: [
+        { name: 'key' },
+        { 'code' => 'invalid_params', 'message' => '`reset_interval` is required' },
+      ],
+      invalid_name: [
+        { name: '\tkey' },
+        { 'code' => 'invalid_params', 'message' => '`name` is the invalid format' }
+      ]
+    )
+    test 'return an error object' do |(param, expected_error)|
+      @client.init(:name => 'key1', :reset_interval => 10).get
+      response = @client.init(param).get
+      errors = response.errors.first
+
+      assert_empty response.data
+      assert_equal expected_error, errors
+    end
+
+    test 'return an existing value when passed key already exists and ignore option is true' do
+      res1 = @client.init(name: 'key1', reset_interval: 10).get
+      res2 = nil
+      assert_nothing_raised do
+        res2 = @client.init({ name: 'key1', reset_interval: 10 }, options: { ignore: true }).get
+      end
+      assert_equal res1.data, res2.data
+    end
+
+    test 'return an error object and data object' do
+      param = { name: 'key1', reset_interval: 10 }
+      param2 = { name: 'key2', reset_interval: 10 }
+      @client.init(param).get
+
+      response = @client.init([param2, param]).get
+      data = response.data.first
+      error = response.errors.first
+
+      assert_equal param2[:name], data['name']
+      assert_equal param2[:reset_interval], data['reset_interval']
+
+      assert_equal 'invalid_params', error['code']
+      assert_equal "#{@scope}\t#{param[:name]} already exists in counter", error['message']
+    end
+
+    test 'return a future object when async call' do
+      param = { name: 'key', reset_interval: 10 }
+      r = @client.init(param)
+      assert_true r.is_a?(Fluent::Counter::Future)
+      assert_nil r.errors
+    end
+  end
+
+  sub_test_case 'delete' do
+    setup do
+      @client.instance_variable_set(:@scope, @scope)
+      @name = 'key'
+      @key = Fluent::Counter::Store.gen_key(@scope, @name)
+
+      @init_obj = { name: @name, reset_interval: 20, type: 'numeric' }
+      @client.init(@init_obj).get
+    end
+
+    test 'delete a value' do
+      assert extract_value_from_server(@server, @scope, @name)
+
+      response = @client.delete(@name).get
+      v = response.data.first
+
+      assert_nil response.errors
+      assert_equal @init_obj[:name], v['name']
+      assert_equal @init_obj[:type], v['type']
+      assert_equal @init_obj[:reset_interval], v['reset_interval']
+
+      assert_nil extract_value_from_server(@server, @scope, @name)
+    end
+
+    test 'raise an error when @scope is nil' do
+      @client.instance_variable_set(:@scope, nil)
+      assert_raise 'Call `establish` method to get a `scope` before calling this method' do
+        @client.delete(@name).get
+      end
+    end
+
+    data(
+      key_not_found: [
+        'key2',
+        { 'code' => 'unknown_key', 'message' => "`worker1\tplugin1\tkey2` doesn't exist in counter" }
+      ],
+      invalid_key: [
+        '\tkey',
+        { 'code' => 'invalid_params', 'message' => '`key` is the invalid format' }
+      ]
+    )
+    test 'return an error object' do |(param, expected_error)|
+      response = @client.delete(param).get
+      errors = response.errors.first
+
+      assert_empty response.data
+      assert_equal expected_error, errors
+    end
+
+    test 'return an error object and data object' do
+      unknown_name = 'key2'
+
+      response = @client.delete(@name, unknown_name).get
+      data = response.data.first
+      error = response.errors.first
+
+      assert_equal @name, data['name']
+      assert_equal @init_obj[:reset_interval], data['reset_interval']
+
+      assert_equal 'unknown_key', error['code']
+      assert_equal "`#{@scope}\t#{unknown_name}` doesn't exist in counter", error['message']
+
+      assert_nil extract_value_from_server(@server, @scope, @name)
+    end
+
+    test 'return a future object when async call' do
+      r = @client.delete(@name)
+      assert_true r.is_a?(Fluent::Counter::Future)
+      assert_nil r.errors
+    end
+  end
+
+  sub_test_case 'inc' do
+    setup do
+      @client.instance_variable_set(:@scope, @scope)
+      @name = 'key'
+      @key = Fluent::Counter::Store.gen_key(@scope, @name)
+
+      @init_obj = { name: @name, reset_interval: 20, type: 'numeric' }
+      @client.init(@init_obj).get
+    end
+
+    test 'increment a value' do
+      v = extract_value_from_server(@server, @scope, @name)
+      assert_equal 0, v['total']
+      assert_equal 0, v['current']
+
+      Timecop.travel(1)
+      inc_obj = { name: @name, value: 10 }
+      @client.inc(inc_obj).get
+
+      v = extract_value_from_server(@server, @scope, @name)
+      assert_equal inc_obj[:value], v['total']
+      assert_equal inc_obj[:value], v['current']
+      assert_equal (@now + 1), Fluent::EventTime.new(*v['last_modified_at'])
+    end
+
+    test 'create and increment a value when force option is true' do
+      name = 'new_key'
+      param = { name: name, value: 11, reset_interval: 1 }
+
+      assert_nil extract_value_from_server(@server, @scope, name)
+
+      @client.inc(param, options: { force: true }).get
+
+      v = extract_value_from_server(@server, @scope, name)
+      assert v
+      assert_equal param[:name], v['name']
+      assert_equal 1, v['reset_interval']
+      assert_equal param[:value], v['current']
+      assert_equal param[:value], v['total']
+    end
+
+    test 'raise an error when @scope is nil' do
+      @client.instance_variable_set(:@scope, nil)
+      assert_raise 'Call `establish` method to get a `scope` before calling this method' do
+        @client.inc(name: 'name', value: 1).get
+      end
+    end
+
+    data(
+      not_exist_key: [
+        { name: 'key2', value: 10 },
+        { 'code' => 'unknown_key', 'message' => "`worker1\tplugin1\tkey2` doesn't exist in counter" }
+      ],
+      missing_name: [
+        { value: 10 },
+        { 'code' => 'invalid_params', 'message' => '`name` is required' },
+      ],
+      missing_value: [
+        { name: 'key' },
+        { 'code' => 'invalid_params', 'message' => '`value` is required' },
+      ],
+      invalid_name: [
+        { name: '\tkey' },
+        { 'code' => 'invalid_params', 'message' => '`name` is the invalid format' }
+      ]
+    )
+    test 'return an error object' do |(param, expected_error)|
+      response = @client.inc(param).get
+      errors = response.errors.first
+      assert_empty response.data
+      assert_equal expected_error, errors
+    end
+
+    test 'return an error object and data object' do
+      parmas = [
+        { name: @name, value: 10 },
+        { name: 'unknown_key', value: 9 },
+      ]
+      response = @client.inc(parmas).get
+
+      data = response.data.first
+      error = response.errors.first
+
+      assert_equal @name, data['name']
+      assert_equal 10, data['current']
+      assert_equal 10, data['total']
+
+      assert_equal 'unknown_key', error['code']
+      assert_equal "`#{@scope}\tunknown_key` doesn't exist in counter", error['message']
+    end
+
+    test 'return a future object when async call' do
+      param = { name: 'key', value: 10 }
+      r = @client.inc(param)
+      assert_true r.is_a?(Fluent::Counter::Future)
+      assert_nil r.errors
+    end
+  end
+
+  sub_test_case 'get' do
+    setup do
+      @client.instance_variable_set(:@scope, @scope)
+      @name = 'key'
+
+      @init_obj = { name: @name, reset_interval: 20, type: 'numeric' }
+      @client.init(@init_obj).get
+    end
+
+    test 'get a value' do
+      v1 = extract_value_from_server(@server, @scope, @name)
+      v2 = @client.get(@name).data.first
+
+      assert_equal v1['name'], v2['name']
+      assert_equal v1['current'], v2['current']
+      assert_equal v1['total'], v2['total']
+      assert_equal v1['type'], v2['type']
+    end
+
+    test 'raise an error when @scope is nil' do
+      @client.instance_variable_set(:@scope, nil)
+      assert_raise 'Call `establish` method to get a `scope` before calling this method' do
+        @client.get(@name).get
+      end
+    end
+
+    data(
+      key_not_found: [
+        'key2',
+        { 'code' => 'unknown_key', 'message' => "`worker1\tplugin1\tkey2` doesn't exist in counter" }
+      ],
+      invalid_key: [
+        '\tkey',
+        { 'code' => 'invalid_params', 'message' => '`key` is the invalid format' }
+      ]
+    )
+    test 'return an error object' do |(param, expected_error)|
+      response = @client.get(param).get
+      errors = response.errors.first
+      assert_empty response.data
+      assert_equal expected_error, errors
+    end
+
+    test 'return an error object and data object' do
+      unknown_name = 'key2'
+
+      response = @client.get(@name, unknown_name).get
+      data = response.data.first
+      error = response.errors.first
+
+      assert_equal @name, data['name']
+      assert_equal @init_obj[:reset_interval], data['reset_interval']
+
+      assert_equal 'unknown_key', error['code']
+      assert_equal "`#{@scope}\t#{unknown_name}` doesn't exist in counter", error['message']
+    end
+
+    test 'return a future object when async call' do
+      r = @client.get(@name)
+      assert_true r.is_a?(Fluent::Counter::Future)
+      assert_nil r.errors
+    end
+  end
+
+  sub_test_case 'reset' do
+    setup do
+      @client.instance_variable_set(:@scope, @scope)
+      @name = 'key'
+      @key = Fluent::Counter::Store.gen_key(@scope, @name)
+
+      @init_obj = { name: @name, reset_interval: 5, type: 'numeric' }
+      @client.init(@init_obj).get
+      @inc_obj = { name: @name, value: 10 }
+      @client.inc(@inc_obj).get
+    end
+
+    test 'reset a value after `reset_interval` passed' do
+      v1 = extract_value_from_server(@server, @scope, @name)
+      assert_equal @inc_obj[:value], v1['total']
+      assert_equal @inc_obj[:value], v1['current']
+      assert_equal @now, Fluent::EventTime.new(*v1['last_reset_at'])
+
+      travel_sec = 6            # greater than reset_interval
+      Timecop.travel(travel_sec)
+
+      v2 = @client.reset(@name).get
+      data = v2.data.first
+
+      c = data['counter_data']
+
+      assert_equal travel_sec, data['elapsed_time']
+      assert_true data['success']
+
+      assert_equal @inc_obj[:value], c['current']
+      assert_equal @inc_obj[:value], c['total']
+      assert_equal @now, c['last_reset_at']
+
+      v1 = extract_value_from_server(@server, @scope, @name)
+      assert_equal 0, v1['current']
+      assert_equal @inc_obj[:value], v1['total']
+      assert_equal (@now + travel_sec), Fluent::EventTime.new(*v1['last_reset_at'])
+      assert_equal (@now + travel_sec), Fluent::EventTime.new(*v1['last_modified_at'])
+    end
+
+    test 'areturn a value object before `reset_interval` passed' do
+      v1 = extract_value_from_server(@server, @scope, @name)
+      assert_equal @inc_obj[:value], v1['total']
+      assert_equal @inc_obj[:value], v1['current']
+      assert_equal @now, Fluent::EventTime.new(*v1['last_reset_at'])
+
+      travel_sec = 4            # less than reset_interval
+      Timecop.travel(travel_sec)
+
+      v2 = @client.reset(@name).get
+      data = v2.data.first
+
+      c = data['counter_data']
+
+      assert_equal travel_sec, data['elapsed_time']
+      assert_equal false, data['success']
+
+      assert_equal @inc_obj[:value], c['current']
+      assert_equal @inc_obj[:value], c['total']
+      assert_equal @now, c['last_reset_at']
+
+      v1 = extract_value_from_server(@server, @scope, @name)
+      assert_equal @inc_obj[:value], v1['current']
+      assert_equal @inc_obj[:value], v1['total']
+      assert_equal @now, Fluent::EventTime.new(*v1['last_reset_at'])
+    end
+
+    test 'raise an error when @scope is nil' do
+      @client.instance_variable_set(:@scope, nil)
+      assert_raise 'Call `establish` method to get a `scope` before calling this method' do
+        @client.reset(@name).get
+      end
+    end
+
+    data(
+      key_not_found: [
+        'key2',
+        { 'code' => 'unknown_key', 'message' => "`worker1\tplugin1\tkey2` doesn't exist in counter" }
+      ],
+      invalid_key: [
+        '\tkey',
+        { 'code' => 'invalid_params', 'message' => '`key` is the invalid format' }
+      ]
+    )
+    test 'return an error object' do |(param, expected_error)|
+      response = @client.reset(param).get
+      errors = response.errors.first
+      assert_empty response.data
+      assert_equal expected_error, errors
+    end
+
+    test 'return an error object and data object' do
+      unknown_name = 'key2'
+
+      travel_sec = 6            # greater than reset_interval
+      Timecop.travel(travel_sec)
+
+      response = @client.reset(@name, unknown_name).get
+      data = response.data.first
+      error = response.errors.first
+      counter = data['counter_data']
+
+      assert_true data['success']
+      assert_equal travel_sec, data['elapsed_time']
+      assert_equal @name, counter['name']
+      assert_equal @init_obj[:reset_interval], counter['reset_interval']
+      assert_equal @inc_obj[:value], counter['total']
+      assert_equal @inc_obj[:value], counter['current']
+
+      assert_equal 'unknown_key', error['code']
+      assert_equal "`#{@scope}\t#{unknown_name}` doesn't exist in counter", error['message']
+
+      v1 = extract_value_from_server(@server, @scope, @name)
+      assert_equal 0, v1['current']
+      assert_equal @inc_obj[:value], v1['total']
+      assert_equal (@now + travel_sec), Fluent::EventTime.new(*v1['last_reset_at'])
+      assert_equal (@now + travel_sec), Fluent::EventTime.new(*v1['last_modified_at'])
+    end
+
+    test 'return a future object when async call' do
+      r = @client.reset(@name)
+      assert_true r.is_a?(Fluent::Counter::Future)
+      assert_nil r.errors
+    end
+  end
+end