logstash-codec-json 2.0.2 → 2.0.3

data/vendor/gems/stud-0.0.22/lib/stud/secret.rb

@@ -0,0 +1,35 @@
+
+# A class for holding a secret. The main goal is to prevent the common mistake
+# of accidentally logging or printing passwords or other secrets.
+#
+# See
+# <https://github.com/jordansissel/software-patterns/blob/master/dont-log-secrets/ruby/>
+# for a discussion of why this implementation is useful.
+module Stud
+  class Secret
+    # Initialize a new secret with a given value.
+    #
+    # value - anything you want to keep secret from loggers, etc.
+    def initialize(secret_value)
+      # Redefine the 'value' method on this instance. This exposes no instance
+      # variables to be accidentally leaked by things like awesome_print, etc.
+      # This makes any #value call return the secret value.
+      (class << self; self; end).class_eval do
+        define_method(:value) { secret_value }
+      end
+    end # def initialize
+
+    # Emit simply "<secret>" when printed or logged.
+    def to_s
+      return "<secret>"
+    end # def to_s
+
+    alias_method :inspect, :to_s
+
+    # Get the secret value.
+    def value
+      # Nothing, this will be filled in by Secret.new
+      # But we'll still document this so rdoc/yard know the method exists.
+    end # def value
+  end # class Secret
+end # class Stud

data/vendor/gems/stud-0.0.22/lib/stud/task.rb

@@ -0,0 +1,64 @@
+require "thread"
+require "stud/interval"
+
+module Stud
+
+  # A Task spawns a thread to execute the given block. execution completion and result retrieval is
+  # done using the Task#wait method. A Task is run once and the thread exists upon block completion.
+  # A task and its underlying thread are not reusable.
+  #
+  # Task does not provide a mean to force-interrupt a running task, it only provides the #stop!
+  # method to signal the task for a stop request. The task or code block can use the #stop? method
+  # to check for a stop request. Note that the #stop! and #stop? methods are thread safe.
+  class Task
+    # provide access to the underlying thread if ever needed.
+    attr_reader :thread
+
+    def initialize(*args, &block)
+      # A queue to receive the result of the block
+      # TODO(sissel): Don't use a queue, just store it in an instance variable.
+      @queue = Queue.new
+
+      @thread = Thread.new(@queue, *args) do |queue, *args|
+        begin
+          result = block.call(*args)
+          queue << [:return, result]
+        rescue => e
+          queue << [:exception, e]
+        end
+      end # thread
+    end # def initialize
+
+    # wait waits for the task thread to complete and return the block return value
+    # if the block raises an exception, this exception is propagated in this
+    # wait method.
+    # @return [Object, Exception] block return value
+    def wait
+      @thread.join
+      reason, result = @queue.pop
+
+      if reason == :exception
+        #raise StandardError.new(result)
+        raise result
+      else
+        return result
+      end
+    end # def wait
+
+    # stop! requests the task to stop. the Thread#wakeup method is also
+    # called so that a sleeping task is waked up and has a chance to verify
+    # the stop request using the #stop? method. also see Stud.stop!
+    def stop!
+      Stud.stop!(@thread)
+    end
+
+    # stop? returns true if this task stop! has been called
+    # See Stud.stop?
+    # @return [Boolean] true if the stop! has been called
+    def stop?
+      Stud.stop?(@thread)
+    end
+    alias_method :interrupted?, :stop?
+
+  end # class Task
+end # module Stud

data/vendor/gems/stud-0.0.22/lib/stud/temporary.rb

@@ -0,0 +1,63 @@
+require "securerandom" # for uuid generation
+require "fileutils"
+
+module Stud
+  module Temporary
+    DEFAULT_PREFIX = "studtmp"
+
+    # Returns a string for a randomly-generated temporary path.
+    #
+    # This does not create any files.
+    def pathname(prefix=DEFAULT_PREFIX)
+
+      root = ENV["TMP"] || ENV["TMPDIR"] || ENV["TEMP"] || "/tmp"
+      return File.join(root, "#{prefix}-#{SecureRandom.hex(30)}")
+    end
+
+    # Return a File handle to a randomly-generated path.
+    #
+    # Any arguments beyond the first (prefix) argument will be
+    # given to File.new.
+    #
+    # If no file args are given, the default file mode is "w+"
+    def file(prefix=DEFAULT_PREFIX, *args, &block)
+      args << "w+" if args.empty?
+      file = File.new(pathname(prefix), *args)
+      if block_given?
+        begin
+          block.call(file)
+        ensure
+          file.close unless file.closed?
+          File.unlink(file.path)
+        end
+      else
+        return file
+      end
+    end
+
+    # Make a temporary directory.
+    #
+    # If given a block, the directory path is given to the block.  WHen the
+    # block finishes, the directory and all its contents will be deleted.
+    #
+    # If no block given, it will return the path to a newly created directory.
+    # You are responsible for then cleaning up.
+    def directory(prefix=DEFAULT_PREFIX, &block)
+      path = pathname(prefix)
+      Dir.mkdir(path)
+
+      if block_given?
+        begin
+          block.call(path)
+        ensure
+          FileUtils.rm_r(path)
+        end
+      else
+        return path
+      end
+    end
+    extend self
+  end # module Temporary
+
+end # module Stud
+

data/vendor/gems/stud-0.0.22/lib/stud/trap.rb

@@ -0,0 +1,80 @@
+module Stud
+  # Bind a block to be called when a certain signal is received.
+  #
+  # Same arguments to Signal::trap.
+  #
+  # The behavior of this method is different than Signal::trap because
+  # multiple handlers can request notification for the same signal.
+  #
+  # For example, this is valid:
+  #
+  #     Stud.trap("INT") { puts "Hello" }
+  #     Stud.trap("INT") { puts "World" }
+  #
+  # When SIGINT is received, both callbacks will be invoked, in order.
+  #
+  # This helps avoid the situation where a library traps a signal outside of
+  # your control.
+  #
+  # If something has already used Signal::trap, that callback will be saved
+  # and scheduled the same way as any other Stud::trap.
+  def self.trap(signal, &block)
+    @traps ||= Hash.new { |h,k| h[k] = [] }
+
+    if !@traps.include?(signal)
+      # First trap call for this signal, tell ruby to invoke us.
+      previous_trap = Signal::trap(signal) { simulate_signal(signal) }
+      # If there was a previous trap (via Kernel#trap) set, make sure we remember it.
+      if previous_trap.is_a?(Proc)
+        # MRI's default traps are "DEFAULT" string
+        # JRuby's default traps are Procs with a source_location of "(internal")
+        if RUBY_ENGINE != "jruby" || previous_trap.source_location.first != "(internal)"
+          @traps[signal] << previous_trap
+        end
+      end
+    end
+
+    @traps[signal] << block
+
+    return block.object_id
+  end # def self.trap
+
+  # Simulate a signal. This lets you force an interrupt without
+  # sending a signal to yourself.
+  def self.simulate_signal(signal)
+    #puts "Simulate: #{signal} w/ #{@traps[signal].count} callbacks"
+    @traps[signal].each(&:call)
+  end # def self.simulate_signal
+
+  # Remove a previously set signal trap.
+  #
+  # 'signal' is the name of the signal ("INT", etc)
+  # 'id' is the value returned by a previous Stud.trap() call
+  def self.untrap(signal, id)
+    @traps[signal].delete_if { |block| block.object_id == id }
+
+    # Restore the default handler if there are no custom traps anymore.
+    if @traps[signal].empty?
+      @traps.delete(signal)
+      Signal::trap(signal, "DEFAULT")
+    end
+  end # def self.untrap
+end # module Stud
+
+# Monkey-patch the main 'trap' stuff? This could be useful.
+#module Signal
+  #def trap(signal, value=nil, &block)
+    #if value.nil?
+      #Stud.trap(signal, &block)
+    #else
+      ## do nothing?
+    #end
+  #end # def trap
+#end
+#
+#module Kernel
+  #def trap(signal, value=nil, &block)
+    #Signal.trap(signal, value, &block)
+  #end
+#end
+

data/vendor/gems/stud-0.0.22/lib/stud/try.rb

@@ -0,0 +1,127 @@
+module Stud
+
+  # A class implementing 'retry-on-failure'
+  #
+  # Example:
+  #
+  #     Try.new.try(5.times) { your_code }
+  #
+  # A failure is indicated by any exception being raised.
+  # On success, the return value of the block is the return value of the try
+  # call.
+  #
+  # On final failure (ran out of things to try), the last exception is raised.
+  class Try
+    # An infinite enumerator
+    class Forever
+      include Enumerable
+      def each(&block)
+        a = 0
+        yield a += 1 while true
+      end
+    end # class Forever
+
+    FOREVER = Forever.new
+
+    BACKOFF_SCHEDULE = [0.01, 0.02, 0.04, 0.08, 0.16, 0.32, 0.64, 1.28, 2.0]
+
+    DEFAULT_CATCHABLE_EXCEPTIONS = [StandardError]
+
+    # Log a failure.
+    #
+    # You should override this method if you want a better logger.
+    def log_failure(exception, fail_count, message)
+      puts "Failed (#{exception}). #{message}"
+    end # def log_failure
+
+    # This method is called when a try attempt fails.
+    #
+    # The default implementation will sleep with exponential backoff up to a
+    # maximum of 2 seconds (see BACKOFF_SCHEDULE)
+    #
+    # exception - the exception causing the failure
+    # fail_count - how many times we have failed.
+    def failure(exception, fail_count)
+      backoff = BACKOFF_SCHEDULE[fail_count] || BACKOFF_SCHEDULE.last
+      log_failure(exception, fail_count, "Sleeping for #{backoff}")
+      sleep(backoff)
+    end # def failure
+
+    # Public: try a block of code until either it succeeds or we give up.
+    #
+    # enumerable - an Enumerable or omitted/nil, #each is invoked and is tried
+    #   that number of times. If this value is omitted or nil, we will try until
+    #   success with no limit on the number of tries.
+    #
+    # exceptions - the type of exceptions to retry, we use `StandardError` by default.
+    #
+    # Returns the return value of the block once the block succeeds.
+    # Raises the last seen exception if we run out of tries.
+    #
+    # Examples
+    #
+    #   # Try 10 times to fetch http://google.com/
+    #   response = try(10.times) { Net::HTTP.get_response("google.com", "/") }
+    #
+    #   # Try many times, yielding the value of the enumeration to the block.
+    #   # This allows you to try different inputs.
+    #   response = try([0, 2, 4, 6]) { |val| 50 / val }
+    #   
+    #   Output: 
+    #   Failed (divided by 0). Retrying in 0.01 seconds...
+    #   => 25
+    #
+    #   # Try forever
+    #   return_value = try { ... }
+    def try(enumerable=FOREVER, exceptions=DEFAULT_CATCHABLE_EXCEPTIONS, &block)
+      if block.arity == 0
+        # If the block takes no arguments, give none
+        procedure = lambda { |val| return block.call }
+      else
+        # Otherwise, pass the current 'enumerable' value to the block.
+        procedure = lambda { |val| return block.call(val) }
+      end
+
+      # Track the last exception so we can reraise it on failure.
+      last_exception = nil
+
+      # When 'enumerable' runs out of things, if we still haven't succeeded,
+      # we'll reraise
+      fail_count = 0
+      enumerable.each do |val|
+        begin
+          # If the 'procedure' (the block, really) succeeds, we'll break 
+          # and return the return value of the block. Win!
+          return procedure.call(val)
+        rescue NoMethodError, NameError
+          # Abort immediately on exceptions that are unlikely to recover.
+          raise
+        rescue *exceptions => exception
+          last_exception = exception
+          fail_count += 1
+
+          # Note: Since we can't reliably detect the 'end' of an enumeration, we
+          # will call 'failure' for the final iteration (if it failed) and sleep
+          # even though there's no strong reason to backoff on the last error.
+          failure(exception, fail_count)
+        end
+      end # enumerable.each
+
+      # generally make the exception appear from the 'try' method itself, not from
+      # any deeply nested enumeration/begin/etc
+      # It is my hope that this makes the backtraces easier to read, not more
+      # difficult. If you find this is not the case, please please please let me
+      # know.
+      last_exception.set_backtrace(StandardError.new.backtrace)
+      raise last_exception
+    end # def try
+  end # class Stud::Try
+
+  TRY = Try.new
+  # A simple try method for the common case.
+  def try(enumerable=Stud::Try::FOREVER, exceptions=Try::DEFAULT_CATCHABLE_EXCEPTIONS, &block)
+    return TRY.try(enumerable, exceptions, &block)
+  end # def try
+
+  extend self
+end # module Stud

data/vendor/gems/stud-0.0.22/lib/stud/with.rb

@@ -0,0 +1,22 @@
+module Stud
+  module With
+    # Run a block with arguments. This is sometimes useful in lieu of
+    # explicitly assigning variables.
+    # 
+    # I find mainly that using 'with' is a clue that I can factor out
+    # a given segment of code into a method or function.
+    #
+    # Example usage:
+    #
+    #   with(TCPSocket.new("google.com", 80)) do |s|
+    #     s.write("GET / HTTP/1.0\r\nHost: google.com\r\n\r\n")
+    #     puts s.read
+    #     s.close
+    #   end
+    def with(*args, &block)
+      block.call(*args)
+    end
+
+    extend self
+  end
+end

data/vendor/gems/thread_safe-0.3.5-java/Gemfile

@@ -0,0 +1,17 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :development, :test do
+  gem 'minitest', '~> 5.5.1'
+  gem 'minitest-reporters', '~> 1.0.11'
+  gem 'simplecov', '~> 0.9.2', :require => false
+  gem 'coveralls', '~> 0.7.11', :require => false
+end
+
+group :documentation do
+  gem 'countloc', '~> 0.4.0', :platforms => :mri, :require => false
+  gem 'yard', '~> 0.8.7.6', :require => false
+  gem 'inch', '~> 0.5.10', :platforms => :mri, :require => false
+  gem 'redcarpet', '~> 3.2.2', platforms: :mri # understands github markdown
+end

data/vendor/gems/thread_safe-0.3.5-java/LICENSE

@@ -0,0 +1,144 @@
+Apache License
+
+Version 2.0, January 2004
+
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction, and distribution as 
+defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by the copyright owner that 
+is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all other entities that 
+control, are controlled by, or are under common control with that entity. For the purposes 
+of this definition, "control" means (i) the power, direct or indirect, to cause the 
+direction or management of such entity, whether by contract or otherwise, or (ii) ownership 
+of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of 
+such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by 
+this License.
+
+"Source" form shall mean the preferred form for making modifications, including but not 
+limited to software source code, documentation source, and configuration files.
+
+"Object" form shall mean any form resulting from mechanical transformation or translation of 
+a Source form, including but not limited to compiled object code, generated documentation, 
+and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or Object form, made available 
+under the License, as indicated by a copyright notice that is included in or attached to the 
+work (an example is provided in the Appendix below).
+
+"Derivative Works" shall mean any work, whether in Source or Object form, that is based on 
+(or derived from) the Work and for which the editorial revisions, annotations, elaborations, 
+or other modifications represent, as a whole, an original work of authorship. For the 
+purposes of this License, Derivative Works shall not include works that remain separable 
+from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works 
+thereof.
+
+"Contribution" shall mean any work of authorship, including the original version of the Work 
+and any modifications or additions to that Work or Derivative Works thereof, that is 
+intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by 
+an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the 
+purposes of this definition, "submitted" means any form of electronic, verbal, or written 
+communication sent to the Licensor or its representatives, including but not limited to 
+communication on electronic mailing lists, source code control systems, and issue tracking 
+systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and 
+improving the Work, but excluding communication that is conspicuously marked or otherwise 
+designated in writing by the copyright owner as "Not a Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a 
+Contribution has been received by Licensor and subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of this License, each 
+Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, 
+royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, 
+publicly display, publicly perform, sublicense, and distribute the Work and such Derivative 
+Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of this License, each 
+Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, 
+royalty-free, irrevocable (except as stated in this section) patent license to make, have 
+made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license 
+applies only to those patent claims licensable by such Contributor that are necessarily 
+infringed by their Contribution(s) alone or by combination of their Contribution(s) with the 
+Work to which such Contribution(s) was submitted. If You institute patent litigation against 
+any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or 
+a Contribution incorporated within the Work constitutes direct or contributory patent 
+infringement, then any patent licenses granted to You under this License for that Work shall 
+terminate as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works 
+thereof in any medium, with or without modifications, and in Source or Object form, provided 
+that You meet the following conditions:
+
+You must give any other recipients of the Work or Derivative Works a copy of this License; 
+and
+
+You must cause any modified files to carry prominent notices stating that You changed the 
+files; and
+
+You must retain, in the Source form of any Derivative Works that You distribute, all 
+copyright, patent, trademark, and attribution notices from the Source form of the Work, 
+excluding those notices that do not pertain to any part of the Derivative Works; and
+
+If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative 
+Works that You distribute must include a readable copy of the attribution notices contained 
+within such NOTICE file, excluding those notices that do not pertain to any part of the 
+Derivative Works, in at least one of the following places: within a NOTICE text file 
+distributed as part of the Derivative Works; within the Source form or documentation, if 
+provided along with the Derivative Works; or, within a display generated by the Derivative 
+Works, if and wherever such third-party notices normally appear. The contents of the NOTICE 
+file are for informational purposes only and do not modify the License. You may add Your own 
+attribution notices within Derivative Works that You distribute, alongside or as an addendum 
+to the NOTICE text from the Work, provided that such additional attribution notices cannot 
+be construed as modifying the License. You may add Your own copyright statement to Your 
+modifications and may provide additional or different license terms and conditions for use, 
+reproduction, or distribution of Your modifications, or for any such Derivative Works as a 
+whole, provided Your use, reproduction, and distribution of the Work otherwise complies with 
+the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution 
+intentionally submitted for inclusion in the Work by You to the Licensor shall be under the 
+terms and conditions of this License, without any additional terms or conditions. 
+Notwithstanding the above, nothing herein shall supersede or modify the terms of any 
+separate license agreement you may have executed with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade names, trademarks, 
+service marks, or product names of the Licensor, except as required for reasonable and 
+customary use in describing the origin of the Work and reproducing the content of the NOTICE 
+file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, 
+Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" 
+BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, 
+without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, 
+MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for 
+determining the appropriateness of using or redistributing the Work and assume any risks 
+associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory, whether in tort 
+(including negligence), contract, or otherwise, unless required by applicable law (such as 
+deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be 
+liable to You for damages, including any direct, indirect, special, incidental, or 
+consequential damages of any character arising as a result of this License or out of the use 
+or inability to use the Work (including but not limited to damages for loss of goodwill, 
+work stoppage, computer failure or malfunction, or any and all other commercial damages or 
+losses), even if such Contributor has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative 
+Works thereof, You may choose to offer, and charge a fee for, acceptance of support, 
+warranty, indemnity, or other liability obligations and/or rights consistent with this 
+License. However, in accepting such obligations, You may act only on Your own behalf and on 
+Your sole responsibility, not on behalf of any other Contributor, and only if You agree to 
+indemnify, defend, and hold each Contributor harmless for any liability incurred by, or 
+claims asserted against, such Contributor by reason of your accepting any such warranty or 
+additional liability.
+
+END OF TERMS AND CONDITIONS