logstash-input-beats 0.9.2 → 0.9.3

data/vendor/jruby/1.9/gems/jls-grok-0.11.2/lib/grok-pure.rb

@@ -1,206 +0,0 @@
-require "rubygems"
-require "logger"
-require "cabin"
-require "grok/pure/discovery"
-require "grok/pure/match"
-
-# TODO(sissel): Check if 'grok' c-ext has been loaded and abort?
-class Grok
-  class PatternError < StandardError; end
-
-  # The pattern input
-  attr_accessor :pattern
-
-  # The fully-expanded pattern (in regex form)
-  attr_accessor :expanded_pattern
-
-  # The logger
-  attr_accessor :logger
-
-  # The dictionary of pattern names to pattern expressions
-  attr_accessor :patterns
-
-  PATTERN_RE = \
-    /%\{    # match '%{' not prefixed with '\'
-       (?<name>     # match the pattern name
-         (?<pattern>[A-z0-9]+)
-         (?::(?<subname>[@\[\]A-z0-9_:.-]+))?
-       )
-       (?:=(?<definition>
-         (?:
-           (?:[^{}\\]+|\\.+)+
-           |
-           (?<curly>\{(?:(?>[^{}]+|(?>\\[{}])+)|(\g<curly>))*\})+
-         )+
-       ))?
-       [^}]*
-     \}/x
-
-  GROK_OK = 0
-  GROK_ERROR_FILE_NOT_ACCESSIBLE = 1
-  GROK_ERROR_PATTERN_NOT_FOUND = 2
-  GROK_ERROR_UNEXPECTED_READ_SIZE = 3
-  GROK_ERROR_COMPILE_FAILED = 4
-  GROK_ERROR_UNINITIALIZED = 5
-  GROK_ERROR_PCRE_ERROR = 6
-  GROK_ERROR_NOMATCH = 7
-
-  public
-  def initialize
-    @patterns = {}
-    @logger = Cabin::Channel.new
-    @logger.subscribe(Logger.new(STDOUT))
-    @logger.level = :warn
-    # Captures Lambda which is generated at Grok compile time and called at match time
-    @captures_func = nil
-
-    # TODO(sissel): Throw exception if we aren't using Ruby 1.9.2 or newer.
-  end # def initialize
-
-  public
-  def add_pattern(name, pattern)
-    @logger.info("Adding pattern", name => pattern)
-    @patterns[name] = pattern
-    return nil
-  end # def add_pattern
-
-  public
-  def add_patterns_from_file(path)
-    file = File.new(path, "r")
-    file.each do |line|
-      # Skip comments
-      next if line =~ /^\s*#/
-      # File format is: NAME ' '+ PATTERN '\n'
-      name, pattern = line.gsub(/^\s*/, "").split(/\s+/, 2)
-      #p name => pattern
-      # If the line is malformed, skip it.
-      next if pattern.nil?
-      # Trim newline and add the pattern.
-      add_pattern(name, pattern.chomp)
-    end
-    return nil
-  ensure
-    file.close
-  end # def add_patterns_from_file
-
-  public
-  def compile(pattern, named_captures_only=false)
-    iterations_left = 10000
-    @pattern = pattern
-    @expanded_pattern = pattern.clone
-
-    # Replace any instances of '%{FOO}' with that pattern.
-    loop do
-      if iterations_left == 0
-        raise PatternError, "Deep recursion pattern compilation of #{pattern.inspect} - expanded: #{@expanded_pattern.inspect}"
-      end
-      iterations_left -= 1
-      m = PATTERN_RE.match(@expanded_pattern)
-      break if !m
-
-      if m["definition"]
-        add_pattern(m["pattern"], m["definition"])
-      end
-
-      if @patterns.include?(m["pattern"])
-        regex = @patterns[m["pattern"]]
-        name = m["name"]
-
-        if named_captures_only && name.index(":").nil?
-          # this has no semantic (pattern:foo) so we don't need to capture
-          replacement_pattern = "(?:#{regex})"
-        else
-          replacement_pattern = "(?<#{name}>#{regex})"
-        end
-
-        # Ruby's String#sub() has a bug (or misfeature) that causes it to do bad
-        # things to backslashes in string replacements, so let's work around it
-        # See this gist for more details: https://gist.github.com/1491437
-        # This hack should resolve LOGSTASH-226.
-        @expanded_pattern.sub!(m[0]) { |s| replacement_pattern }
-        @logger.debug? and @logger.debug("replacement_pattern => #{replacement_pattern}")
-      else
-        raise PatternError, "pattern #{m[0]} not defined"
-      end
-    end
-
-    @regexp = Regexp.new(@expanded_pattern, Regexp::MULTILINE)
-    @logger.debug? and @logger.debug("Grok compiled OK", :pattern => pattern,
-                                     :expanded_pattern => @expanded_pattern)
-
-    @captures_func = compile_captures_func(@regexp)
-  end
-
-  private
-  # compiles the captures lambda so runtime match can be optimized
-  def compile_captures_func(re)
-    re_match = ["lambda do |match, &block|"]
-    re.named_captures.each do |name, indices|
-      pattern, name, coerce = name.split(":")
-      indices.each do |index|
-        coerce = case coerce
-                   when "int"; ".to_i"
-                   when "float"; ".to_f"
-                   else; ""
-                 end
-        name = pattern if name.nil?
-        if coerce
-          re_match << "  m = match[#{index}]"
-          re_match << "  block.call(#{name.inspect}, (m ? m#{coerce} : m))"
-        else
-          re_match << "  block.call(#{name.inspect}, match[#{index}])"
-        end
-      end
-    end
-    re_match << "end"
-    return eval(re_match.join("\n"))
-  end # def compile_captures_func
-
-  public
-  def match(text)
-    match = @regexp.match(text)
-    if match
-      grokmatch = Grok::Match.new
-      grokmatch.subject = text
-      grokmatch.grok = self
-      grokmatch.match = match
-      @logger.debug? and @logger.debug("Regexp match object", :names => match.names,
-                                       :captures => match.captures)
-      return grokmatch
-    else
-      return false
-    end
-  end # def match
-
-  # Optimized match and capture instead of calling them separately
-  def match_and_capture(text)
-    match = @regexp.match(text)
-    if match
-      @logger.debug? and @logger.debug("Regexp match object", :names => match.names,
-                                       :captures => match.captures)
-      @captures_func.call(match) { |k,v| yield k,v }
-      return true
-    else
-      return false
-    end
-  end # def match_and_capture
-
-  def capture(match, block)
-    @captures_func.call(match) { |k,v| block.call k,v }
-  end # def capture
-
-  public
-  def discover(input)
-    init_discover if @discover == nil
-
-    return @discover.discover(input)
-  end # def discover
-
-  private
-  def init_discover
-    require "grok/pure/discovery"
-    @discover = Grok::Discovery.new(self)
-    @discover.logger = @logger
-  end # def init_discover
-
-end # Grok

data/vendor/jruby/1.9/gems/jls-grok-0.11.2/lib/grok.rb

@@ -1,133 +0,0 @@
-require "rubygems"
-require "ffi"
-
-# TODO(sissel): Check if 'grok-pure' has been loaded and abort?
-class Grok < FFI::Struct
-  module CGrok
-    extend FFI::Library
-    ffi_lib "libgrok"
-
-    attach_function :grok_new, [], :pointer
-    attach_function :grok_compilen, [:pointer, :pointer, :int], :int
-    attach_function :grok_pattern_add,
-                    [:pointer, :pointer, :int, :pointer, :int], :int
-    attach_function :grok_patterns_import_from_file, [:pointer, :pointer], :int
-    attach_function :grok_execn, [:pointer, :pointer, :int, :pointer], :int
-  end
-
-  include CGrok
-  layout :pattern, :string,
-         :pattern_len, :int,
-         :full_pattern, :string,
-         :full_pattern_len, :int,
-         :__patterns, :pointer, # TCTREE*, technically
-         :__re, :pointer, # pcre*
-         :__pcre_capture_vector, :pointer, # int*
-         :__pcre_num_captures, :int,
-         :__captures_by_id, :pointer, # TCTREE*
-         :__captures_by_name, :pointer, # TCTREE*
-         :__captures_by_subname, :pointer, # TCTREE*
-         :__captures_by_capture_number, :pointer, # TCTREE*
-         :__max_capture_num, :int,
-         :pcre_errptr, :string,
-         :pcre_erroffset, :int,
-         :pcre_errno, :int,
-         :logmask, :uint,
-         :logdepth, :uint,
-         :errstr, :string
-
-  GROK_OK = 0
-  GROK_ERROR_FILE_NOT_ACCESSIBLE = 1
-  GROK_ERROR_PATTERN_NOT_FOUND = 2
-  GROK_ERROR_UNEXPECTED_READ_SIZE = 3
-  GROK_ERROR_COMPILE_FAILED = 4
-  GROK_ERROR_UNINITIALIZED = 5
-  GROK_ERROR_PCRE_ERROR = 6
-  GROK_ERROR_NOMATCH = 7
-
-  public
-  def initialize
-    super(grok_new)
-  end
-
-  public
-  def add_pattern(name, pattern)
-    name_c = FFI::MemoryPointer.from_string(name)
-    pattern_c = FFI::MemoryPointer.from_string(pattern)
-    grok_pattern_add(self, name_c, name.length, pattern_c, pattern.length)
-    return nil
-  end
-
-  public
-  def add_patterns_from_file(path)
-    path_c = FFI::MemoryPointer.from_string(path)
-    ret = grok_patterns_import_from_file(self, path_c)
-    if ret != GROK_OK
-      raise ArgumentError, "Failed to add patterns from file #{path}"
-    end
-    return nil
-  end
-
-  public
-  def pattern
-    return self[:pattern]
-  end
-
-  public
-  def expanded_pattern
-    return self[:full_pattern]
-  end
-
-  public
-  def compile(pattern)
-    pattern_c = FFI::MemoryPointer.from_string(pattern)
-    ret = grok_compilen(self, pattern_c, pattern.length)
-    if ret != GROK_OK
-      raise ArgumentError, "Compile failed: #{self[:errstr]})"
-    end
-    return ret
-  end
-
-  public
-  def match(text)
-    match = Grok::Match.new
-    text_c = FFI::MemoryPointer.from_string(text)
-    rc = grok_execn(self, text_c, text.size, match)
-    case rc
-    when GROK_OK
-      # Give the Grok::Match object a reference to the 'text_c'
-      # object which is also Grok::Match#subject string;
-      # this will prevent Ruby from garbage collecting it until
-      # the match object is garbage collectd.
-      #
-      # If we don't do this, then 'text_c' will fall out of
-      # scope at the end of this function and become a candidate
-      # for garbage collection, causing Grok::Match#subject to become
-      # corrupt and any captures to point to those corrupt portions.
-      # http://code.google.com/p/logstash/issues/detail?id=47
-      match.subject_memorypointer = text_c
-
-      return match
-    when GROK_ERROR_NOMATCH
-      return false
-    end
-
-    raise ValueError, "unknown return from grok_execn: #{rc}"
-  end
-
-  public
-  def discover(input)
-    init_discover if @discover == nil
-
-    return @discover.discover(input)
-  end
-
-  private
-  def init_discover
-    @discover = GrokDiscover.new(self)
-    @discover.logmask = logmask
-  end
-end # Grok
-
-require "grok/c-ext/match"
-require "grok/c-ext/pile"

data/vendor/jruby/1.9/gems/jrjackson-0.2.9/Gemfile

@@ -1,9 +0,0 @@
-# A sample Gemfile
-source "https://rubygems.org"
-
-group :development do
-  gem 'gson', '>= 0.6'
-  gem 'json', '~> 1.8'
-end
-
-gemspec

data/vendor/jruby/1.9/gems/jrjackson-0.2.9/README.md

@@ -1,112 +0,0 @@
-
-
-LICENSE applicable to this library:
-
-Apache License 2.0 see http://www.apache.org/licenses/LICENSE-2.0
-
-### JrJackson:
-
-a jruby library wrapping the JAVA Jackson jars`
-
-__NOTE:__ Smile support has been temporarily dropped
-
-The code has been refactored to use almost all Java.
-
-There is now a MultiJson adapter added for JrJackson
-
-***
-
-#### NEWS
-
-11th May 2014 - Added to_time method call for Ruby object serialization
-
-26th October 2013 - Added support to serialize arbitary (non JSON datatypes)
-ruby objects.  Normally the toJava internal method is called, but additionally
-to_h, to_hash, to_a and finally to_json are tried.  Be aware that the to_json
-method might invoke a new selialization session and impact performance. 
-
-***
-
-#### API
-
-```
-JrJackson::Json.load(string, options) -> hash like object
-      aliased as parse
-```
-By default the load method will return Ruby objects (Hashes have string keys).
-The options hash respects three symbol keys
-
-+ :symbolize_keys
-
-  Will return symbol keys in hashes
-
-+ :raw
-
-  Will return JRuby wrapped java objects that quack like ruby objects
-  This is the fastest option
-
-+ :use_bigdecimal
-
-  Will return BigDecimal objects instead of Float
-  If used with the :raw option you will get Java::JavaMath::BigDecimal objects
-  otherwise they are Ruby BigDecimal
-
-```
-JrJackson::Json.dump(obj) -> json string
-      aliased as generate
-```
-The dump method expects that the values of hashes or arrays are JSON data types,
-the only exception to this is Ruby Symbol as values, they are converted to java strings
-during serialization. __NOTE:__ All other objects should be converted to JSON data types before
-serialization. See the wiki for more on this.
-
-***
-
-#### Internals
-
-There are two Ruby sub modules of the JrJackson module
-
-```JrJackson::Json```, this is the general external facade used by MultiJson, and is pure Ruby.
-
-```JrJackson::Raw```, this is used by the Json module, it is defined in Java with annotations
-exposing it as a Ruby module with module methods.
-
-***
-
-#### Benchmarks
-
-Credit to Chuck Remes for the benchmark and initial
-investigation when the jruby, json gem and the jackson
-libraries were young.
-
-I compared Json (java) 1.8, Gson 0.6.1 and jackson 2.2.3 on jruby 1.7.5 and OpenJDK 64-Bit Server VM 1.7.0_25-b30
-All the benchmarks were run separately. A 727.9KB string of random json data is read from a file and handled 250 times, thereby attempting to balance invocation and parsing benchmarking.
-
-```
-generation/serialize
-
-                                               user     system      total         real
-json mri generate: 250                        12.02       0.00      12.02     ( 12.022)
-oj mri generate: 250                           7.18       0.00       7.18     (  7.183)
-json java generate: 250                        7.83       0.01       7.84     (  7.289)
-gson generate: 250                             5.04       0.00       5.04     (  4.995)
-jackson generate: 250                          4.94       0.08       5.02     (  4.811)
-jackson generate: 250                          4.85       0.04       4.89     (  4.758)
-
-
-parsing/deserialize - after jrjackson parsing profiling
-
-                                               user     system      total         real
-json mri parse: 250                            8.35       0.02       8.37     (  8.366)
-oj mri parse: 250                              6.10       0.13       6.23     (  7.527)
-      
-gson parse: 250                               12.02       0.02      12.04     ( 11.774)
-json java parse: 250                          10.35       0.01      10.36     ( 10.204)
-jackson parse string keys: 250                 5.60       0.00       5.60     (  5.356)
-jackson parse string + bigdecimal: 250         5.14       0.01       5.15     (  4.946)
-jackson parse symbol keys: 250                 4.16       0.01       4.17     (  3.989)
-jackson parse symbol + bigdecimal: 250         3.90       0.03       3.93     (  3.597)
-jackson parse raw: 250                         3.08       0.01       3.09     (  2.924)
-jackson parse raw + bigdecimal: 250            2.70       0.06       2.76     (  2.493)
-
-```

data/vendor/jruby/1.9/gems/jrjackson-0.2.9/Rakefile

@@ -1,10 +0,0 @@
-require 'rspec/core/rake_task'
-require 'bundler'
-
-Bundler::GemHelper.install_tasks
-
-desc "Run benchmarks"
-task :benchmark do
-  load 'benchmarking/benchmark.rb'
-end
-

data/vendor/jruby/1.9/gems/jrjackson-0.2.9/changelog.md

@@ -1,80 +0,0 @@
-v0.2.8
-  fixes for issues-28,29,31
-    correction for Time#to_s
-    new options to control date serialization
-    optimizations suggested by @headius
-  jar compiled for jruby 1.7.17
-  jruby 1.7.17
-  jackson 2.4.4
-
-v0.2.7
-  fixes for issues-23,24
-    add to_time as option for serializing Time like objects
-  jar compiled for jruby 1.7.11
-
-v0.2.6
-  fix issue-20
-    allow jruby to convert Ruby StringIO into Java
-    by not type checking passed arg
-    this is because jruby 1.7.9 has changed the type of java object backing Ruby StringIO
-  jar compiled for jruby 1.7.8 (jruby 1.7.9 in the maven repo has an error in the pom.xml)
-  jruby 1.7.8, jruby 1.7.9 (tested)
-  jackson 2.3.0
-
-v0.2.5
-  fix issue-16
-    reduce the gem size by:
-      change pom.xml to only include relevant java jars
-      exclude benchmaking from the gemspec files
-  jruby 1.7.5
-  jackson 2.2.3
-
-v0.2.4
-  fix issue-15
-    return Ruby nil instead of Java null
-  fix issue-14
-    remove all usage of Ruby.getGlobalRuntime
-    pass the runtime from the calling Ruby ThreadContext into the deserializers and converters
-  jruby 1.7.5
-  jackson 2.2.3
-
-v0.2.3
-  fix issue-12
-    improve the serialization support for non Json Datatype Ruby objects
-    now has support for serializing via toJava, to_h, to_hash, to_a, to_json
-  fix for failing MultiJson unicode test
-  jruby 1.7.4
-  jackson 2.2.3
-
-v0.2.2
-  fix issue-13
-    compile Java for 1.6 compatibility
-  documentation tweaks
-  jruby 1.7.4
-  jackson 2.2.3
-
-v0.2.1
-  documentation tweaks
-  fix issue-7
-    add pluggable String and Symbol Converters for JSON values
-  jruby 1.7.4
-  jackson 2.2.3
-
-v0.2.0
-  extract all Java -> Ruby generation to reusable RubyUtils static class
-  support BigDecimal
-  remove JSON Api
-  fixes issues 5, 6, 8, 
-
-  jruby 1.7.3
-  jackson 2.2.2
-
-v0.1.1
-  fix Time regex
-v0.1.0
-  MutiJson compatibility
-  switch to using almost all Java, i.e. define most of the ruby modules in Java
-  jruby 1.7.3
-  jackson 2.1.4
-v0.0.7
-  first release - minimal jruby wrapper around jackson 1.9.5 jars

data/vendor/jruby/1.9/gems/jrjackson-0.2.9/dependency-reduced-pom.xml

@@ -1,87 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
-  <modelVersion>4.0.0</modelVersion>
-  <groupId>com.jrjackson.jruby</groupId>
-  <artifactId>jrjackson</artifactId>
-  <name>jrjackson</name>
-  <version>1.2.12</version>
-  <url>http://maven.apache.org</url>
-  <build>
-    <plugins>
-      <plugin>
-        <artifactId>maven-compiler-plugin</artifactId>
-        <version>3.1</version>
-        <configuration>
-          <source>1.6</source>
-          <target>1.6</target>
-          <showDeprecation>false</showDeprecation>
-          <showWarnings>false</showWarnings>
-          <executable>${JAVA_HOME_6}/bin/javac</executable>
-          <fork>true</fork>
-        </configuration>
-      </plugin>
-      <plugin>
-        <artifactId>maven-surefire-plugin</artifactId>
-        <version>2.17</version>
-        <configuration>
-          <skipTests>true</skipTests>
-        </configuration>
-      </plugin>
-      <plugin>
-        <artifactId>maven-shade-plugin</artifactId>
-        <version>2.3</version>
-        <executions>
-          <execution>
-            <phase>package</phase>
-            <goals>
-              <goal>shade</goal>
-            </goals>
-            <configuration>
-              <minimizeJar>true</minimizeJar>
-              <artifactSet>
-                <includes>
-                  <include>com.fasterxml.jackson.core:*</include>
-                  <include>com.fasterxml.jackson.module:jackson-module-afterburner</include>
-                </includes>
-              </artifactSet>
-            </configuration>
-          </execution>
-        </executions>
-      </plugin>
-    </plugins>
-  </build>
-  <dependencies>
-    <dependency>
-      <groupId>junit</groupId>
-      <artifactId>junit</artifactId>
-      <version>4.11</version>
-      <scope>test</scope>
-      <exclusions>
-        <exclusion>
-          <artifactId>hamcrest-core</artifactId>
-          <groupId>org.hamcrest</groupId>
-        </exclusion>
-      </exclusions>
-    </dependency>
-    <dependency>
-      <groupId>org.jruby</groupId>
-      <artifactId>jruby</artifactId>
-      <version>1.7.17</version>
-      <scope>provided</scope>
-      <exclusions>
-        <exclusion>
-          <artifactId>jruby-core</artifactId>
-          <groupId>org.jruby</groupId>
-        </exclusion>
-        <exclusion>
-          <artifactId>jruby-stdlib</artifactId>
-          <groupId>org.jruby</groupId>
-        </exclusion>
-      </exclusions>
-    </dependency>
-  </dependencies>
-  <properties>
-    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-  </properties>
-</project>
-

data/vendor/jruby/1.9/gems/jrjackson-0.2.9/jrjackson.gemspec

@@ -1,23 +0,0 @@
-#! /usr/bin/env jruby
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-
-require 'jrjackson/build_info'
-
-Gem::Specification.new do |s|
-  s.name        = 'jrjackson'
-  s.version     = JrJackson::BuildInfo.version
-  s.date        = JrJackson::BuildInfo.release_date
-  s.platform    = Gem::Platform::RUBY
-  s.authors     = ['Guy Boertje']
-  s.email       = ['guyboertje@gmail.com']
-  s.homepage    = "http://github.com/guyboertje/jrjackson"
-  s.summary     = %q{A JRuby wrapper for the java jackson json processor jar}
-  s.description = %q{A mostly native JRuby wrapper for the java jackson json processor jar}
-  s.license     = 'Apache License 2.0'
-
-  s.add_development_dependency 'bundler', '~> 1.0'
-
-  s.files = JrJackson::BuildInfo.files
-
-end

data/vendor/jruby/1.9/gems/jrjackson-0.2.9/lib/jrjackson/build_info.rb

@@ -1,15 +0,0 @@
-module JrJackson
-  module BuildInfo
-    def self.version
-      '0.2.9'
-    end
-
-    def self.release_date
-      '2015-06-24'
-    end
-
-    def self.files
-      `git ls-files`.split($/).select{|f| f !~ /\Abenchmarking/}
-    end
-  end
-end