fluentd 1.14.4-x64-mingw-ucrt

data/lib/fluent/timezone.rb

@@ -0,0 +1,171 @@
+#
+# 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 'tzinfo'
+
+require 'fluent/config/error'
+
+# For v0.12. Will be removed after v2
+module IntegerExt
+  refine Integer do
+    def to_time
+      Time.at(self)
+    end
+  end
+end
+
+module Fluent
+  class Timezone
+    # [+-]HH:MM, [+-]HHMM, [+-]HH
+    NUMERIC_PATTERN = %r{\A[+-]\d\d(:?\d\d)?\z}
+
+    # Region/Zone, Region/Zone/Zone
+    NAME_PATTERN = %r{\A[^/]+/[^/]+(/[^/]+)?\z}
+
+    # Validate the format of the specified timezone.
+    #
+    # Valid formats are as follows. Note that timezone abbreviations
+    # such as PST and JST are not supported intentionally.
+    #
+    #   1. [+-]HH:MM         (e.g. "+09:00")
+    #   2. [+-]HHMM          (e.g. "+0900")
+    #   3. [+-]HH            (e.g. "+09")
+    #   4. Region/Zone       (e.g. "Asia/Tokyo")
+    #   5. Region/Zone/Zone  (e.g. "America/Argentina/Buenos_Aires")
+    #
+    # In the 4th and 5th cases, it is checked whether the specified
+    # timezone exists in the timezone database.
+    #
+    # When the given timezone is valid, true is returned. Otherwise,
+    # false is returned. When nil is given, false is returned.
+    def self.validate(timezone)
+      # If the specified timezone is nil.
+      if timezone.nil?
+        # Invalid.
+        return false
+      end
+
+      # [+-]HH:MM, [+-]HHMM, [+-]HH
+      if NUMERIC_PATTERN === timezone
+        # Valid. It can be parsed by Time.zone_offset method.
+        return true
+      end
+
+      # Region/Zone, Region/Zone/Zone
+      if NAME_PATTERN === timezone
+        begin
+          # Get a Timezone instance for the specified timezone.
+          TZInfo::Timezone.get(timezone)
+        rescue
+          # Invalid. The string does not exist in the timezone database.
+          return false
+        else
+          # Valid. The string was found in the timezone database.
+          return true
+        end
+      else
+        # Invalid. Timezone abbreviations are not supported.
+        return false
+      end
+    end
+
+    # Validate the format of the specified timezone.
+    #
+    # The implementation of this method calls validate(timezone) method
+    # to check whether the given timezone is valid. When invalid, this
+    # method raises a ConfigError.
+    def self.validate!(timezone)
+      unless validate(timezone)
+        raise ConfigError, "Unsupported timezone '#{timezone}'"
+      end
+    end
+
+    using IntegerExt
+
+    # Create a formatter for a timezone and optionally a format.
+    #
+    # An Proc object is returned. If the given timezone is invalid,
+    # nil is returned.
+    def self.formatter(timezone = nil, format = nil)
+      if timezone.nil?
+        return nil
+      end
+
+      # [+-]HH:MM, [+-]HHMM, [+-]HH
+      if NUMERIC_PATTERN === timezone
+        offset = Time.zone_offset(timezone)
+
+        case
+        when format.is_a?(String)
+          return Proc.new {|time|
+            time.to_time.localtime(offset).strftime(format)
+          }
+        when format.is_a?(Strftime)
+          return Proc.new {|time|
+            format.exec(time.to_time.localtime(offset))
+          }
+        else
+          return Proc.new {|time|
+            time.to_time.localtime(offset).iso8601
+          }
+        end
+      end
+
+      # Region/Zone, Region/Zone/Zone
+      if NAME_PATTERN === timezone
+        begin
+          tz = TZInfo::Timezone.get(timezone)
+        rescue
+          return nil
+        end
+
+        case
+        when format.is_a?(String)
+          return Proc.new {|time|
+            time = time.to_time
+            time.localtime(tz.period_for_utc(time).utc_total_offset).strftime(format)
+          }
+        when format.is_a?(Strftime)
+          return Proc.new {|time|
+            time = time.to_time
+            format.exec(time.localtime(tz.period_for_utc(time).utc_total_offset))
+          }
+        else
+          return Proc.new {|time|
+            time = time.to_time
+            time.localtime(tz.period_for_utc(time).utc_total_offset).iso8601
+          }
+        end
+      end
+
+      return nil
+    end
+
+    def self.utc_offset(timezone)
+      return 0 if timezone.nil?
+
+      case timezone
+      when NUMERIC_PATTERN
+        Time.zone_offset(timezone)
+      when NAME_PATTERN
+        tz = TZInfo::Timezone.get(timezone)
+        ->(time) {
+          tz.period_for_utc(time.to_time).utc_total_offset
+        }
+      end
+    end
+  end
+end

data/lib/fluent/tls.rb

@@ -0,0 +1,81 @@
+#
+# 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 'openssl'
+require 'fluent/config/error'
+
+module Fluent
+  module TLS
+    DEFAULT_VERSION = :'TLSv1_2'
+    SUPPORTED_VERSIONS = if defined?(OpenSSL::SSL::TLS1_3_VERSION)
+                           [:'TLSv1_1', :'TLSv1_2', :'TLSv1_3', :'TLS1_1', :'TLS1_2', :'TLS1_3'].freeze
+                         else
+                           [:'TLSv1_1', :'TLSv1_2', :'TLS1_1', :'TLS1_2'].freeze
+                         end
+    ### follow httpclient configuration by nahi
+    # OpenSSL 0.9.8 default: "ALL:!ADH:!LOW:!EXP:!MD5:+SSLv2:@STRENGTH"
+    CIPHERS_DEFAULT = "ALL:!aNULL:!eNULL:!SSLv2".freeze # OpenSSL >1.0.0 default
+
+    METHODS_MAP = begin
+                    map = {
+                      TLSv1: OpenSSL::SSL::TLS1_VERSION,
+                      TLSv1_1: OpenSSL::SSL::TLS1_1_VERSION,
+                      TLSv1_2: OpenSSL::SSL::TLS1_2_VERSION
+                    }
+                    map[:'TLSv1_3'] = OpenSSL::SSL::TLS1_3_VERSION if defined?(OpenSSL::SSL::TLS1_3_VERSION)
+                    MIN_MAX_AVAILABLE = true
+                    map.freeze
+                  rescue NameError
+                    # ruby 2.4 doesn't have OpenSSL::SSL::TLSXXX constants and min_version=/max_version= methods
+                    map = {
+                      TLS1: :'TLSv1',
+                      TLS1_1: :'TLSv1_1',
+                      TLS1_2: :'TLSv1_2',
+                    }.freeze
+                    MIN_MAX_AVAILABLE = false
+                    map
+                  end
+    private_constant :METHODS_MAP
+
+    # Helper for old syntax/method support:
+    # ruby 2.4 uses ssl_version= but this method is now deprecated.
+    # min_version=/max_version= use 'TLS1_2' but ssl_version= uses 'TLSv1_2'
+    def set_version_to_context(ctx, version, min_version, max_version)
+      if MIN_MAX_AVAILABLE
+        case
+        when min_version.nil? && max_version.nil?
+          min_version = METHODS_MAP[version] || version
+          max_version = METHODS_MAP[version] || version
+        when min_version.nil? && max_version
+          raise Fluent::ConfigError, "When you set max_version, must set min_version together"
+        when min_version && max_version.nil?
+          raise Fluent::ConfigError, "When you set min_version, must set max_version together"
+        else
+          min_version = METHODS_MAP[min_version] || min_version
+          max_version = METHODS_MAP[max_version] || max_version
+        end
+        ctx.min_version = min_version
+        ctx.max_version = max_version
+      else
+        ctx.ssl_version = METHODS_MAP[version] || version
+      end
+
+      ctx
+    end
+    module_function :set_version_to_context
+  end
+end
+

data/lib/fluent/unique_id.rb

@@ -0,0 +1,39 @@
+#
+# 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.
+#
+
+module Fluent
+  module UniqueId
+    def self.generate
+      now = Time.now.utc
+      u1 = ((now.to_i * 1000 * 1000 + now.usec) << 12 | rand(0xfff))
+      [u1 >> 32, u1 & 0xffffffff, rand(0xffffffff), rand(0xffffffff)].pack('NNNN')
+    end
+
+    def self.hex(unique_id)
+      unique_id.unpack('H*').first
+    end
+
+    module Mixin
+      def generate_unique_id
+        Fluent::UniqueId.generate
+      end
+
+      def dump_unique_id_hex(unique_id)
+        Fluent::UniqueId.hex(unique_id)
+      end
+    end
+  end
+end

data/lib/fluent/variable_store.rb

@@ -0,0 +1,40 @@
+#
+# 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.
+#
+
+module Fluent
+  # VariableStore provides all pluigns with the way to shared variable without using class variable
+  # it's for safe reloading mechanism
+  class VariableStore
+    @data = {}
+
+    class << self
+      def fetch_or_build(namespace, default_value: {})
+        @data[namespace] ||= default_value
+      end
+
+      def try_to_reset
+        @data, old = {}, @data
+
+        begin
+          yield
+        rescue
+          @data = old
+          raise
+        end
+      end
+    end
+  end
+end

data/lib/fluent/version.rb

@@ -0,0 +1,21 @@
+#
+# 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.
+#
+
+module Fluent
+
+  VERSION = '1.14.4'
+
+end

data/lib/fluent/winsvc.rb

@@ -0,0 +1,103 @@
+#
+# 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.
+#
+
+begin
+
+  require 'optparse'
+  require 'windows/debug'
+  require 'Windows/Library'
+  require 'win32/daemon'
+  require 'win32/event'
+
+  include Win32
+  include Windows::Library
+  include Windows::Debug
+
+  op = OptionParser.new
+  opts = {service_name: nil}
+  op.on('--service-name NAME', "The name of the Windows Service") {|name|
+    opts[:service_name] = name
+  }
+  op.parse(ARGV)
+  if opts[:service_name] == nil
+    raise "Error: No Windows Service name set. Use '--service-name'"
+  end 
+
+  def read_fluentdopt(service_name)
+    require 'win32/Registry'
+    Win32::Registry::HKEY_LOCAL_MACHINE.open("SYSTEM\\CurrentControlSet\\Services\\#{service_name}") do |reg|
+      reg.read("fluentdopt")[1] rescue ""
+    end
+  end
+
+  def service_main_start(service_name)
+    ruby_path = 0.chr * 260
+    GetModuleFileName.call(0, ruby_path,260)
+    ruby_path = ruby_path.rstrip.gsub(/\\/, '/')
+    rubybin_dir = ruby_path[0, ruby_path.rindex("/")]
+    opt = read_fluentdopt(service_name)
+    Process.spawn("\"#{rubybin_dir}/ruby.exe\" \"#{rubybin_dir}/fluentd\" #{opt} -x #{service_name}")
+  end
+
+  class FluentdService < Daemon
+    @pid = 0
+    @service_name = ''
+
+    def initialize(service_name)
+      @service_name = service_name
+    end
+    
+    def service_main
+      @pid = service_main_start(@service_name)
+      while running?
+        sleep 10
+      end
+    end
+
+    def service_stop
+      set_event(@service_name)
+      if @pid > 0
+        Process.waitpid(@pid)
+      end
+    end
+
+    def service_paramchange
+      set_event("#{@service_name}_USR2")
+    end
+
+    def service_user_defined_control(code)
+      case code
+      when 128
+        set_event("#{@service_name}_HUP")
+      when 129
+        set_event("#{@service_name}_USR1")
+      end
+    end
+
+    private
+
+    def set_event(event_name)
+      ev = Win32::Event.open(event_name)
+      ev.set
+      ev.close
+    end
+  end
+
+  FluentdService.new(opts[:service_name]).mainloop
+
+rescue Exception => err
+  raise
+end

data/templates/new_gem/Gemfile

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

data/templates/new_gem/README.md.erb

@@ -0,0 +1,43 @@
+# <%= gem_name %>
+
+[Fluentd](https://fluentd.org/) <%= type %> plugin to do something.
+
+TODO: write description for you plugin.
+
+## Installation
+
+### RubyGems
+
+```
+$ gem install <%= gem_name %>
+```
+
+### Bundler
+
+Add following line to your Gemfile:
+
+```ruby
+gem "<%= gem_name %>"
+```
+
+And then execute:
+
+```
+$ bundle
+```
+
+## Configuration
+
+You can generate configuration template:
+
+```
+$ fluent-plugin-config-format <%= type %> <%= name %>
+```
+
+You can copy and paste generated documents here.
+
+## Copyright
+
+* Copyright(c) <%= Date.today.year %>- <%= user_name %>
+* License
+  * <%= @license.full_name %>

data/templates/new_gem/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/templates/new_gem/fluent-plugin.gemspec.erb

@@ -0,0 +1,27 @@
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name    = "<%= gem_name %>"
+  spec.version = "0.1.0"
+  spec.authors = ["<%= user_name %>"]
+  spec.email   = ["<%= user_email %>"]
+
+  spec.summary       = %q{TODO: Write a short summary, because Rubygems requires one.}
+  spec.description   = %q{TODO: Write a longer description or delete this line.}
+  spec.homepage      = "TODO: Put your gem's website or public repo URL here."
+  spec.license       = "<%= @license.name %>"
+
+  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", "~> <%= bundler_version %>"
+  spec.add_development_dependency "rake", "~> <%= rake_version %>"
+  spec.add_development_dependency "test-unit", "~> <%= test_unit_version %>"
+  spec.add_runtime_dependency "fluentd", [">= 0.14.10", "< 2"]
+end

data/templates/new_gem/lib/fluent/plugin/filter.rb.erb

@@ -0,0 +1,14 @@
+<%= preamble %>
+
+require "fluent/plugin/filter"
+
+module Fluent
+  module Plugin
+    class <%= class_name %> < Fluent::Plugin::Filter
+      Fluent::Plugin.register_filter("<%= plugin_name %>", self)
+
+      def filter(tag, time, record)
+      end
+    end
+  end
+end

data/templates/new_gem/lib/fluent/plugin/formatter.rb.erb

@@ -0,0 +1,14 @@
+<%= preamble %>
+
+require "fluent/plugin/formatter"
+
+module Fluent
+  module Plugin
+    class <%= class_name %> < Fluent::Plugin::Formatter
+      Fluent::Plugin.register_formatter("<%= name %>", self)
+
+      def format(tag, time, record)
+      end
+    end
+  end
+end

data/templates/new_gem/lib/fluent/plugin/input.rb.erb

@@ -0,0 +1,11 @@
+<%= preamble %>
+
+require "fluent/plugin/input"
+
+module Fluent
+  module Plugin
+    class <%= class_name %> < Fluent::Plugin::Input
+      Fluent::Plugin.register_input("<%= plugin_name %>", self)
+    end
+  end
+end

data/templates/new_gem/lib/fluent/plugin/output.rb.erb

@@ -0,0 +1,11 @@
+<%= preamble %>
+
+require "fluent/plugin/output"
+
+module Fluent
+  module Plugin
+    class <%= class_name %> < Fluent::Plugin::Output
+      Fluent::Plugin.register_output("<%= plugin_name %>", self)
+    end
+  end
+end

data/templates/new_gem/lib/fluent/plugin/parser.rb.erb

@@ -0,0 +1,15 @@
+<%= preamble %>
+
+require "fluent/plugin/parser"
+
+module Fluent
+  module Plugin
+    class <%= class_name %> < Fluent::Plugin::Parser
+      Fluent::Plugin.register_parser("<%= plugin_name %>", self)
+
+      def parse(text)
+        yield time, record
+      end
+    end
+  end
+end

data/templates/new_gem/lib/fluent/plugin/storage.rb.erb

@@ -0,0 +1,40 @@
+<%= preamble %>
+
+require "fluent/plugin/storage"
+
+module Fluent
+  module Plugin
+    class <%= class_name %> < Fluent::Plugin::Storage
+      Fluent::Plugin.register_storage("<%= plugin_name %>", self)
+
+      def initialize
+        super
+      end
+
+      def configure(conf)
+        super
+      end
+
+      def load
+      end
+
+      def save
+      end
+
+      def get(key)
+      end
+
+      def fetch(key, defval)
+      end
+
+      def put(key, value)
+      end
+
+      def delete(key)
+      end
+
+      def update(key, &block)
+      end
+    end
+  end
+end

data/templates/new_gem/test/helper.rb.erb

@@ -0,0 +1,8 @@
+$LOAD_PATH.unshift(File.expand_path("../../", __FILE__))
+require "test-unit"
+require "fluent/test"
+require "fluent/test/driver/<%= type %>"
+require "fluent/test/helpers"
+
+Test::Unit::TestCase.include(Fluent::Test::Helpers)
+Test::Unit::TestCase.extend(Fluent::Test::Helpers)

data/templates/new_gem/test/plugin/test_filter.rb.erb

@@ -0,0 +1,18 @@
+require "helper"
+require "fluent/plugin/<%= plugin_filename %>"
+
+class <%= class_name %>Test < Test::Unit::TestCase
+  setup do
+    Fluent::Test.setup
+  end
+
+  test "failure" do
+    flunk
+  end
+
+  private
+
+  def create_driver(conf)
+    Fluent::Test::Driver::Filter.new(Fluent::Plugin::<%= class_name %>).configure(conf)
+  end
+end