fluentd 1.20.0-aarch64-mingw-ucrt

data/lib/fluent/plugin/out_exec_filter.rb

@@ -0,0 +1,319 @@
+#
+# 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/output'
+require 'fluent/env'
+require 'fluent/config/error'
+
+require 'json'
+
+module Fluent::Plugin
+  class ExecFilterOutput < Output
+    Fluent::Plugin.register_output('exec_filter', self)
+
+    helpers :compat_parameters, :inject, :formatter, :parser, :extract, :child_process, :event_emitter
+
+    desc 'The command (program) to execute.'
+    config_param :command, :string
+
+    config_param :remove_prefix, :string, default: nil, deprecated: "use @label instead for event routing"
+    config_param :add_prefix, :string, default: nil, deprecated: "use @label instead for event routing"
+
+    config_section :inject do
+      config_set_default :time_type, :unixtime
+    end
+
+    config_section :format do
+      config_set_default :@type, 'tsv'
+      config_set_default :localtime, true
+    end
+
+    config_section :parse do
+      config_set_default :@type, 'tsv'
+      config_set_default :time_key, nil
+      config_set_default :time_format, nil
+      config_set_default :localtime, true
+      config_set_default :estimate_current_event, false
+    end
+
+    config_section :extract do
+      config_set_default :time_type, :float
+    end
+
+    config_section :buffer do
+      config_set_default :flush_mode, :interval
+      config_set_default :flush_interval, 1
+    end
+
+    config_param :tag, :string, default: nil
+
+    config_param :tag_key, :string, default: nil, deprecated: "use 'tag_key' in <inject>/<extract> instead"
+    config_param :time_key, :string, default: nil, deprecated: "use 'time_key' in <inject>/<extract> instead"
+    config_param :time_format, :string, default: nil, deprecated: "use 'time_format' in <inject>/<extract> instead"
+
+    desc 'The default block size to read if parser requires partial read.'
+    config_param :read_block_size, :size, default: 10240 # 10k
+
+    desc 'The number of spawned process for command.'
+    config_param :num_children, :integer, default: 1
+
+    desc 'Respawn command when command exit. ["none", "inf" or positive integer for times to respawn (default: none)]'
+    # nil, 'none' or 0: no respawn, 'inf' or -1: infinite times, positive integer: try to respawn specified times only
+    config_param :child_respawn, :string, default: nil
+
+    # 0: output logs for all of messages to emit
+    config_param :suppress_error_log_interval, :time, default: 0
+
+    attr_reader :formatter, :parser # for tests
+
+    KEYS_FOR_IN_AND_OUT = {
+      'tag_key' => ['in_tag_key', 'out_tag_key'],
+      'time_key' => ['in_time_key', 'out_time_key'],
+      'time_format' => ['in_time_format', 'out_time_format'],
+    }
+    COMPAT_INJECT_PARAMS = {
+      'in_tag_key' => 'tag_key',
+      'in_time_key' => 'time_key',
+      'in_time_format' => 'time_format',
+    }
+    COMPAT_FORMAT_PARAMS = {
+      'in_format' => '@type',
+      'in_keys' => 'keys',
+    }
+    COMPAT_PARSE_PARAMS = {
+      'out_format' => '@type',
+      'out_keys' => 'keys',
+      'out_stream_buffer_size' => 'stream_buffer_size',
+    }
+    COMPAT_EXTRACT_PARAMS = {
+      'out_tag_key' => 'tag_key',
+      'out_time_key' => 'time_key',
+      'out_time_format' => 'time_format',
+    }
+
+    def exec_filter_compat_parameters_copy_to_subsection!(conf, subsection_name, params)
+      return unless conf.elements(subsection_name).empty?
+      return unless params.keys.any?{|k| conf.has_key?(k) }
+      hash = {}
+      params.each_pair do |compat, current|
+        hash[current] = conf[compat] if conf.has_key?(compat)
+      end
+      conf.elements << Fluent::Config::Element.new(subsection_name, '', hash, [])
+    end
+
+    def exec_filter_compat_parameters_convert!(conf)
+      KEYS_FOR_IN_AND_OUT.each_pair do |inout, keys|
+        if conf.has_key?(inout)
+          keys.each do |k|
+            conf[k] = conf[inout]
+          end
+        end
+      end
+      exec_filter_compat_parameters_copy_to_subsection!(conf, 'inject', COMPAT_INJECT_PARAMS)
+      exec_filter_compat_parameters_copy_to_subsection!(conf, 'format', COMPAT_FORMAT_PARAMS)
+      exec_filter_compat_parameters_copy_to_subsection!(conf, 'parse', COMPAT_PARSE_PARAMS)
+      exec_filter_compat_parameters_copy_to_subsection!(conf, 'extract', COMPAT_EXTRACT_PARAMS)
+    end
+
+    def configure(conf)
+      exec_filter_compat_parameters_convert!(conf)
+      compat_parameters_convert(conf, :buffer)
+
+      if inject_section = conf.elements('inject').first
+        if inject_section.has_key?('time_format')
+          inject_section['time_type'] ||= 'string'
+        end
+      end
+      if extract_section = conf.elements('extract').first
+        if extract_section.has_key?('time_format')
+          extract_section['time_type'] ||= 'string'
+        end
+      end
+
+      super
+
+      if !@tag && (!@extract_config || !@extract_config.tag_key)
+        raise Fluent::ConfigError, "'tag' or '<extract> tag_key </extract>' option is required on exec_filter output"
+      end
+
+      @formatter = formatter_create
+      @parser = parser_create
+
+      if @remove_prefix
+        @removed_prefix_string = @remove_prefix + '.'
+        @removed_length = @removed_prefix_string.length
+      end
+      if @add_prefix
+        @added_prefix_string = @add_prefix + '.'
+      end
+
+      @respawns = if @child_respawn.nil? || (@child_respawn == 'none') || (@child_respawn == '0')
+                    0
+                  elsif (@child_respawn == 'inf') || (@child_respawn == '-1')
+                    -1
+                  elsif /^\d+$/.match?(@child_respawn)
+                    @child_respawn.to_i
+                  else
+                    raise ConfigError, "child_respawn option argument invalid: none(or 0), inf(or -1) or positive number"
+                  end
+
+      @suppress_error_log_interval ||= 0
+      @next_log_time = Time.now.to_i
+    end
+
+    def multi_workers_ready?
+      true
+    end
+
+    ExecutedProcess = Struct.new(:mutex, :pid, :respawns, :readio, :writeio)
+
+    def start
+      super
+
+      @children_mutex = Mutex.new
+      @children = []
+      @rr = 0
+
+      exit_callback = ->(status){
+        c = @children.find{|child| child.pid == status.pid }
+        if c
+          unless self.stopped?
+            log.warn "child process exits with error code", code: status.to_i, status: status.exitstatus, signal: status.termsig
+          end
+          c.mutex.synchronize do
+            c.writeio&.close rescue nil
+            c.readio&.close rescue nil
+            c.pid = c.readio = c.writeio = nil
+          end
+        end
+      }
+      child_process_callback = ->(index, readio, writeio){
+        pid = child_process_id
+        c = @children[index]
+        writeio.sync = true
+        c.mutex.synchronize do
+          c.pid = pid
+          c.respawns = @respawns
+          c.readio = readio
+          c.writeio = writeio
+        end
+
+        run(readio)
+      }
+      execute_child_process = ->(index){
+        child_process_execute("out_exec_filter_child#{index}".to_sym, @command, on_exit_callback: exit_callback) do |readio, writeio|
+          child_process_callback.call(index, readio, writeio)
+        end
+      }
+
+      @children_mutex.synchronize do
+        @num_children.times do |i|
+          @children << ExecutedProcess.new(Mutex.new, nil, 0, nil, nil)
+          execute_child_process.call(i)
+        end
+      end
+
+      if @respawns != 0
+        thread_create(:out_exec_filter_respawn_monitor) do
+          while thread_current_running?
+            @children.each_with_index do |c, i|
+              if c.mutex && c.mutex.synchronize{ c.pid.nil? && c.respawns != 0 }
+                respawns = c.mutex.synchronize do
+                  c.respawns -= 1 if c.respawns > 0
+                  c.respawns
+                end
+                log.info "respawning child process", num: i, respawn_counter: respawns
+                execute_child_process.call(i)
+              end
+            end
+            sleep 0.2
+          end
+        end
+      end
+    end
+
+    def terminate
+      @children = []
+      super
+    end
+
+    def tag_remove_prefix(tag)
+      if @remove_prefix
+        if ((tag[0, @removed_length] == @removed_prefix_string) && (tag.length > @removed_length)) || (tag == @removed_prefix_string)
+          tag = tag[@removed_length..-1] || ''
+        end
+      end
+      tag
+    end
+
+    NEWLINE = "\n"
+
+    def format(tag, time, record)
+      tag = tag_remove_prefix(tag)
+      record = inject_values_to_record(tag, time, record)
+      if @formatter.formatter_type == :text_per_line
+        @formatter.format(tag, time, record).chomp + NEWLINE
+      else
+        @formatter.format(tag, time, record)
+      end
+    end
+
+    def write(chunk)
+      try_times = 0
+      while true
+        r = @rr = (@rr + 1) % @children.length
+        if @children[r].pid && writeio = @children[r].writeio
+          chunk.write_to(writeio)
+          break
+        end
+        try_times += 1
+        raise "no healthy child processes exist" if try_times >= @children.length
+      end
+    end
+
+    def run(io)
+      io.set_encoding(Encoding::ASCII_8BIT)
+      case
+      when @parser.implement?(:parse_io)
+        @parser.parse_io(io, &method(:on_record))
+      when @parser.implement?(:parse_partial_data)
+        until io.eof?
+          @parser.parse_partial_data(io.readpartial(@read_block_size), &method(:on_record))
+        end
+      when @parser.parser_type == :text_per_line
+        io.each_line do |line|
+          @parser.parse(line.chomp, &method(:on_record))
+        end
+      else
+        @parser.parse(io.read, &method(:on_record))
+      end
+    end
+
+    def on_record(time, record)
+      tag = extract_tag_from_record(record)
+      tag = @added_prefix_string + tag if tag && @add_prefix
+      tag ||= @tag
+      time ||= extract_time_from_record(record) || Fluent::EventTime.now
+      router.emit(tag, time, record)
+    rescue => e
+      if @suppress_error_log_interval == 0 || Time.now.to_i > @next_log_time
+        log.error "exec_filter failed to emit", record: JSON.generate(record), error: e
+        log.error_backtrace e.backtrace
+        @next_log_time = Time.now.to_i + @suppress_error_log_interval
+      end
+      router.emit_error_event(tag, time, record, e) if tag && time && record
+    end
+  end
+end

data/lib/fluent/plugin/out_file.rb

@@ -0,0 +1,371 @@
+#
+# 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 'fileutils'
+require 'zlib'
+require 'time'
+require 'pathname'
+
+require 'fluent/plugin/output'
+require 'fluent/config/error'
+# TODO remove ...
+require 'fluent/plugin/file_util'
+
+module Fluent::Plugin
+  class FileOutput < Output
+    Fluent::Plugin.register_output('file', self)
+
+    helpers :formatter, :inject, :compat_parameters
+
+    SUPPORTED_COMPRESS = [:text, :gz, :gzip, :zstd]
+    SUPPORTED_COMPRESS_MAP = {
+      text: nil,
+      gz: :gzip,
+      gzip: :gzip,
+      zstd: :zstd,
+    }
+
+    DEFAULT_TIMEKEY = 60 * 60 * 24
+
+    desc "The Path of the file."
+    config_param :path, :string
+
+    desc "Specify to add file suffix for bare file path or not."
+    config_param :add_path_suffix, :bool, default: true
+    desc "The file suffix added to bare file path."
+    config_param :path_suffix, :string, default: '.log'
+    desc "The flushed chunk is appended to existence file or not."
+    config_param :append, :bool, default: false
+    desc "Compress flushed file."
+    config_param :compress, :enum, list: SUPPORTED_COMPRESS, default: :text
+    desc "Execute compression again even when buffer chunk is already compressed."
+    config_param :recompress, :bool, default: false
+    desc "Create symlink to temporary buffered file when buffer_type is file (disabled on Windows)."
+    config_param :symlink_path, :string, default: nil
+    desc "Use relative path for symlink target (default: false)"
+    config_param :symlink_path_use_relative, :bool, default: false
+
+    config_section :format do
+      config_set_default :@type, 'out_file'
+    end
+
+    config_section :buffer do
+      config_set_default :@type, 'file'
+      config_set_default :chunk_keys, ['time']
+      config_set_default :timekey, DEFAULT_TIMEKEY
+    end
+
+    attr_reader :dir_perm
+    attr_accessor :last_written_path # for tests
+
+    module SymlinkBufferMixin
+      def metadata(timekey: nil, tag: nil, variables: nil)
+        metadata = super
+
+        if newer_timekey?(metadata.timekey)
+          synchronize { @latest_timekey = metadata.timekey if newer_timekey?(metadata.timekey) }
+        end
+
+        metadata
+      end
+
+      def output_plugin_for_symlink=(output_plugin)
+        @_output_plugin_for_symlink = output_plugin
+      end
+
+      def symlink_path=(path)
+        @_symlink_path = path
+      end
+
+      def generate_chunk(metadata)
+        chunk = super
+        # "symlink" feature is to link from symlink_path to the latest file chunk. Records with latest
+        # timekey will be appended into that file chunk. On the other side, resumed file chunks might NOT
+        # have timekey, especially in the cases that resumed file chunks are generated by Fluentd v0.12.
+        # These chunks will be enqueued immediately, and will be flushed soon.
+        # Split chunks (seq > 0) are generated outside the buffer lock, so ln_sf would race between threads.
+        if chunk.metadata.timekey && chunk.metadata.seq == 0 && chunk.metadata.timekey == @latest_timekey
+          sym_path = @_output_plugin_for_symlink.extract_placeholders(@_symlink_path, chunk)
+          FileUtils.mkdir_p(File.dirname(sym_path), mode: @_output_plugin_for_symlink.dir_perm)
+          if @_output_plugin_for_symlink.symlink_path_use_relative
+            relative_path = Pathname.new(chunk.path).relative_path_from(Pathname.new(File.dirname(sym_path)))
+            FileUtils.ln_sf(relative_path, sym_path)
+          else
+            FileUtils.ln_sf(chunk.path, sym_path)
+          end
+        end
+        chunk
+      end
+
+      private
+
+      def newer_timekey?(timekey)
+        timekey && (@latest_timekey.nil? || timekey > @latest_timekey)
+      end
+    end
+
+    def configure(conf)
+      compat_parameters_convert(conf, :formatter, :buffer, :inject, default_chunk_key: "time")
+
+      configured_time_slice_format = conf['time_slice_format']
+
+      if conf.elements(name: 'buffer').empty?
+        # no <buffer> section, default time chunk key and timekey (1d) will be used.
+        log.warn "default timekey interval (1d) will be used because of missing <buffer> section. To change the output frequency, please modify the timekey value"
+
+        conf.add_element('buffer', 'time')
+      else
+        unless conf.elements(name: 'buffer').first.has_key?('timekey')
+          if conf.elements(name: 'buffer').first.arg != "[]"
+            # with <buffer> section (except <buffer []>), and no timekey
+            log.warn "default timekey interval (1d) will be used. To change the output frequency, please modify the timekey value"
+          end
+        end
+      end
+      buffer_conf = conf.elements(name: 'buffer').first
+      # Fluent::PluginId#configure is not called yet, so we can't use #plugin_root_dir here.
+      if !buffer_conf.has_key?('path') && !(conf['@id'] && system_config.root_dir)
+        # v0.14 file buffer handles path as directory if '*' is missing
+        # 'dummy_path' is not to raise configuration error for 'path' in file buffer plugin,
+        # but raise it in this plugin.
+        buffer_conf['path'] = conf['path'] || '/tmp/dummy_path'
+      end
+
+      if conf.has_key?('utc') || conf.has_key?('localtime')
+        param_name = conf.has_key?('utc') ? 'utc' : 'localtime'
+        log.warn "'#{param_name}' is deprecated for output plugin. This parameter is used for formatter plugin in compatibility layer. If you want to use same feature, use timekey_use_utc parameter in <buffer> directive instead"
+      end
+
+      super
+
+      @compress_method = SUPPORTED_COMPRESS_MAP[@compress]
+
+      if @path.include?('*') && !@buffer_config.timekey
+        raise Fluent::ConfigError, "path including '*' must be used with buffer chunk key 'time'"
+      end
+
+      path_suffix = @add_path_suffix ? @path_suffix : ''
+      path_timekey = if @chunk_key_time
+                       @as_secondary ? @primary_instance.buffer_config.timekey : @buffer_config.timekey
+                     else
+                       nil
+                     end
+      @path_template = generate_path_template(@path, path_timekey, @append, @compress_method, path_suffix: path_suffix, time_slice_format: configured_time_slice_format)
+
+      if @as_secondary
+        # When this plugin is configured as secondary & primary plugin has tag key, but this plugin may not have it.
+        # Increment placeholder can make another output file per chunk tag/keys even if original path doesn't include it.
+        placeholder_validators(:path, @path_template).select{|v| v.type == :time }.each do |v|
+          v.validate!
+        end
+      else
+        placeholder_validate!(:path, @path_template)
+
+        max_tag_index = get_placeholders_tag(@path_template).max || 1
+        max_tag_index = 1 if max_tag_index < 1
+        dummy_tag = (['a'] * max_tag_index).join('.')
+        dummy_record_keys = get_placeholders_keys(@path_template) || ['message']
+        dummy_record = Hash[dummy_record_keys.zip(['data'] * dummy_record_keys.size)]
+
+        test_chunk1 = chunk_for_test(dummy_tag, Fluent::EventTime.now, dummy_record)
+        test_path = extract_placeholders(@path_template, test_chunk1)
+        unless ::Fluent::FileUtil.writable_p?(test_path)
+          raise Fluent::ConfigError, "out_file: `#{test_path}` is not writable"
+        end
+      end
+
+      @formatter = formatter_create
+
+      if @symlink_path && @buffer.respond_to?(:path)
+        if @as_secondary
+          raise Fluent::ConfigError, "symlink_path option is unavailable in <secondary>: consider to use secondary_file plugin"
+        end
+        if Fluent.windows?
+          log.warn "symlink_path is unavailable on Windows platform. disabled."
+          @symlink_path = nil
+        else
+          placeholder_validators(:symlink_path, @symlink_path).reject{ |v| v.type == :time }.each do |v|
+            begin
+              v.validate!
+            rescue Fluent::ConfigError => e
+              log.warn "#{e}. This means multiple chunks are competing for a single symlink_path, so some logs may not be taken from the symlink."
+            end
+          end
+
+          @buffer.extend SymlinkBufferMixin
+          @buffer.symlink_path = @symlink_path
+          @buffer.output_plugin_for_symlink = self
+        end
+
+        if @compress != :text && @buffer.compress != :text && @buffer.compress != @compress_method
+          raise Fluent::ConfigError, "You cannot specify different compression formats for Buffer (Buffer: #{@buffer.compress}, Self: #{@compress})"
+        end
+      end
+
+      @dir_perm = system_config.dir_permission || Fluent::DEFAULT_DIR_PERMISSION
+      @file_perm = system_config.file_permission || Fluent::DEFAULT_FILE_PERMISSION
+      @need_lock = system_config.workers > 1
+    end
+
+    def multi_workers_ready?
+      true
+    end
+
+    def format(tag, time, record)
+      r = inject_values_to_record(tag, time, record)
+      @formatter.format(tag, time, r)
+    end
+
+    def write(chunk)
+      path = extract_placeholders(@path_template, chunk)
+      FileUtils.mkdir_p File.dirname(path), mode: @dir_perm
+
+      writer = case
+                when @compress_method.nil?
+                  method(:write_without_compression)
+                when @compress_method != :text
+                  if @buffer.compress == :text || @recompress
+                    method(:write_with_compression).curry.call(@compress_method)
+                  else
+                    method(:write_from_compressed_chunk).curry.call(@compress_method)
+                  end
+                else
+                  raise "BUG: unknown compression method #{@compress_method}"
+                end
+
+      if @append
+        if @need_lock
+          acquire_worker_lock(path) do
+            writer.call(path, chunk)
+          end
+        else
+          writer.call(path, chunk)
+        end
+      else
+        find_filepath_available(path, with_lock: @need_lock) do |actual_path|
+          writer.call(actual_path, chunk)
+          path = actual_path
+        end
+      end
+
+      @last_written_path = path
+    end
+
+    def write_without_compression(path, chunk)
+      File.open(path, "ab", @file_perm) do |f|
+        chunk.write_to(f)
+      end
+    end
+
+    def write_with_compression(type, path, chunk)
+      File.open(path, "ab", @file_perm) do |f|
+        gz = nil
+        if type == :gzip
+          gz = Zlib::GzipWriter.new(f)
+        elsif type == :zstd
+          gz = Zstd::StreamWriter.new(f)
+        end
+        chunk.write_to(gz, compressed: :text)
+        gz.close
+      end
+    end
+
+    def write_from_compressed_chunk(type, path, chunk)
+      File.open(path, "ab", @file_perm) do |f|
+        chunk.write_to(f, compressed: type)
+      end
+    end
+
+    def timekey_to_timeformat(timekey)
+      case timekey
+      when nil          then ''
+      when 0...60       then '%Y%m%d%H%M%S' # 60 exclusive
+      when 60...3600    then '%Y%m%d%H%M'
+      when 3600...86400 then '%Y%m%d%H'
+      else                   '%Y%m%d'
+      end
+    end
+
+    def compression_suffix(compress)
+      case compress
+      when :gzip then '.gz'
+      when :zstd then '.zstd'
+      when nil then ''
+      else
+        raise ArgumentError, "unknown compression type #{compress}"
+      end
+    end
+
+    # /path/to/dir/file.*      -> /path/to/dir/file.%Y%m%d
+    # /path/to/dir/file.*.data -> /path/to/dir/file.%Y%m%d.data
+    # /path/to/dir/file        -> /path/to/dir/file.%Y%m%d.log
+    #   %Y%m%d -> %Y%m%d_** (non append)
+    # + .gz (gzipped)
+    ## TODO: remove time_slice_format when end of support of compat_parameters
+    def generate_path_template(original, timekey, append, compress, path_suffix: '', time_slice_format: nil)
+      comp_suffix = compression_suffix(compress)
+      index_placeholder = append ? '' : '_**'
+      if original.index('*')
+        raise "BUG: configuration error must be raised for path including '*' without timekey" unless timekey
+        time_placeholders_part = time_slice_format || timekey_to_timeformat(timekey)
+        original.gsub('*', time_placeholders_part + index_placeholder) + comp_suffix
+      else
+        if timekey
+          if time_slice_format
+            "#{original}.#{time_slice_format}#{index_placeholder}#{path_suffix}#{comp_suffix}"
+          else
+            time_placeholders = timekey_to_timeformat(timekey)
+            if time_placeholders.scan(/../).any?{|ph| original.include?(ph) }
+              raise Fluent::ConfigError, "insufficient timestamp placeholders in path" if time_placeholders.scan(/../).any?{|ph| !original.include?(ph) }
+              "#{original}#{index_placeholder}#{path_suffix}#{comp_suffix}"
+            else
+              "#{original}.#{time_placeholders}#{index_placeholder}#{path_suffix}#{comp_suffix}"
+            end
+          end
+        else
+          "#{original}#{index_placeholder}#{path_suffix}#{comp_suffix}"
+        end
+      end
+    end
+
+    def find_filepath_available(path_with_placeholder, with_lock: false) # for non-append
+      raise "BUG: index placeholder not found in path: #{path_with_placeholder}" unless path_with_placeholder.index('_**')
+      i = 0
+      dir_path = locked = nil
+      while true
+        path = path_with_placeholder.sub('_**', "_#{i}")
+        i += 1
+        next if File.exist?(path)
+
+        if with_lock
+          dir_path = path + '.lock'
+          locked = Dir.mkdir(dir_path) rescue false
+          next unless locked
+          # ensure that other worker doesn't create a file (and release lock)
+          # between previous File.exist? and Dir.mkdir
+          next if File.exist?(path)
+        end
+
+        break
+      end
+      yield path
+    ensure
+      if dir_path && locked && Dir.exist?(dir_path)
+        Dir.rmdir(dir_path) rescue nil
+      end
+    end
+  end
+end