logstash-core 5.6.16-java → 6.0.0.alpha1-java

data/lib/logstash/instrument/global_metrics.rb

@@ -1,13 +0,0 @@
-class GlobalMetrics
-  class Stats(metric)
-    @metric = metric
-  end
-
-  def initialize(metric)
-    @metric = metric
-
-    @pipeline_reloads = metric.namespace([:stats, :pipelines])
-  end
-
-
-end

data/lib/logstash/instrument/periodic_poller/dlq.rb

@@ -1,24 +0,0 @@
-# encoding: utf-8
-require 'logstash/instrument/periodic_poller/base'
-
-module LogStash module Instrument module PeriodicPoller
-  class DeadLetterQueue < Base
-    def initialize(metric, agent, options = {})
-      super(metric, options)
-      @metric = metric
-      @agent = agent
-    end
-
-    def collect
-      pipelines = @agent.get_running_user_defined_pipelines
-      unless pipelines.nil?
-        pipelines.each {|_, pipeline|
-          unless pipeline.nil?
-            pipeline.collect_dlq_stats
-          end
-        }
-      end
-    end
-  end
-end end end
-

data/lib/logstash/modules/cli_parser.rb

@@ -1,74 +0,0 @@
-# encoding: utf-8
-require "logstash/namespace"
-require "logstash/logging"
-require "logstash/errors"
-
-module LogStash module Modules class CLIParser
-  include LogStash::Util::Loggable
-
-  attr_reader :output
-  def initialize(module_names, module_variables)
-    @output = []
-    # The #compact here catches instances when module_variables may be nil or
-    # [nil] and sets it to []
-    parse_it(module_names, Array(module_variables).compact)
-  end
-
-  def parse_modules(module_list)
-    parsed_modules = []
-    module_list.each do |module_value|
-      # Calling --modules but not filling it results in [nil], so skip that.
-      next if module_value.nil?
-      # Catch if --modules was launched empty but an option/flag (-something)
-      # follows immediately after
-      if module_value.start_with?('-')
-        raise LogStash::ConfigLoadingError, I18n.t("logstash.modules.configuration.modules-invalid-name", :module_name => module_value)
-      end
-      parsed_modules.concat module_value.split(',')
-    end
-    parsed_modules
-  end
-
-  def get_kv(module_name, unparsed)
-    # Ensure that there is at least 1 equals sign in our variable string
-    # Using String#partition to split on the first '='
-    # This hackery is to catch the possibility of an equals (`=`) sign
-    # in a passphrase, which might result in an incomplete key.  The
-    # portion before the first `=` should always be the key, leaving
-    # the rest to be the value
-    k, op, rest = unparsed.partition('=')
-    if rest.size.zero?
-      raise LogStash::ConfigLoadingError, I18n.t("logstash.modules.configuration.modules-variables-malformed", :rawvar => (module_name + '.' + unparsed))
-    end
-    return k.strip, rest.strip
-  end
-
-  def name_splitter(unparsed)
-    # It must have at least `modulename.something`
-    module_name, dot, rest = unparsed.partition('.')
-    if rest.count('.') >= 1
-      return module_name, rest
-    else
-      raise LogStash::ConfigLoadingError, I18n.t("logstash.modules.configuration.modules-variables-malformed", :rawvar => unparsed)
-    end
-  end
-
-  def parse_vars(module_name, vars_list)
-    module_hash = {"name" => module_name}
-    vars_list.each do |unparsed|
-      extracted_name, modvar = name_splitter(unparsed)
-      next if extracted_name != module_name
-      k, v = get_kv(extracted_name, modvar)
-      module_hash[k] = v
-    end
-    module_hash
-  end
-
-  def parse_it(module_list, module_variable_list)
-    if module_list.is_a?(Array)
-      parse_modules(module_list).each do |module_name|
-        @output << parse_vars(module_name, module_variable_list)
-      end
-    end
-  end
-end end end

data/lib/logstash/modules/elasticsearch_config.rb

@@ -1,22 +0,0 @@
-# encoding: utf-8
-require "logstash/namespace"
-require "logstash/logging"
-
-require_relative "elasticsearch_resource"
-
-module LogStash module Modules class ElasticsearchConfig
-  attr_reader :index_name
-
-  # We name it `modul` here because `module` has meaning in Ruby.
-  def initialize(modul, settings)
-    @directory = ::File.join(modul.directory, "elasticsearch")
-    @name = modul.module_name
-    @settings = settings
-    @full_path = ::File.join(@directory, "#{@name}.json")
-    @index_name = @settings.fetch("elasticsearch.template_path", "_template")
-  end
-
-  def resources
-    [ElasticsearchResource.new(@index_name, "not-used", @full_path)]
-  end
-end end end

data/lib/logstash/modules/elasticsearch_importer.rb

@@ -1,37 +0,0 @@
-# encoding: utf-8
-require "logstash/namespace"
-require "logstash/logging"
-
-module LogStash module Modules class ElasticsearchImporter
-  include LogStash::Util::Loggable
-
-  def initialize(client)
-    @client = client
-  end
-
-  def put(resource, overwrite = true)
-    path = resource.import_path
-    logger.debug("Attempting PUT", :url_path => path, :file_path => resource.content_path)
-    if !overwrite && content_exists?(path)
-      logger.debug("Found existing Elasticsearch resource.", :resource => path)
-      return
-    end
-    put_overwrite(path, resource.content)
-  end
-
-  private
-
-  def put_overwrite(path, content)
-    if content_exists?(path)
-      response = @client.delete(path)
-    end
-    # hmmm, versioning?
-    @client.put(path, content).status == 201
-  end
-
-  def content_exists?(path)
-    response = @client.head(path)
-    response.status >= 200 && response.status < 300
-  end
-
-end end end # class LogStash::Modules::Importer

data/lib/logstash/modules/elasticsearch_resource.rb

@@ -1,10 +0,0 @@
-# encoding: utf-8
-require "logstash/namespace"
-require_relative "resource_base"
-
-module LogStash module Modules class ElasticsearchResource
-  include ResourceBase
-  def import_path
-    base + "/" + content_id
-  end
-end end end

data/lib/logstash/modules/file_reader.rb

@@ -1,36 +0,0 @@
-# encoding: utf-8
-require "logstash/namespace"
-require "logstash/logging"
-require "logstash/json"
-
-module LogStash module Modules class FileReader
-  # stub these methods for testing
-  include LogStash::Util::Loggable
-
-  def self.read(path)
-    begin
-      ::File.read(path)
-    rescue => e
-      logger.error("Error when reading file from path", :path => path)
-      ""
-    end
-  end
-
-  def self.read_json(path)
-    json = read(path)
-    begin
-      LogStash::Json.load(json)
-    rescue => e
-      logger.error("Error when parsing json from path", :path => path)
-      return {}
-    end
-  end
-
-  def self.glob(path)
-    files = Dir.glob(path)
-    if files.empty?
-      logger.warn("No files found for glob", :pattern => path)
-    end
-    files
-  end
-end end end

data/lib/logstash/modules/kibana_base.rb

@@ -1,24 +0,0 @@
-# encoding: utf-8
-require "logstash/namespace"
-require "logstash/json"
-
-module LogStash module Modules class KibanaBase
-  attr_reader :import_path, :content
-
-  def initialize(import_path, content)
-    @import_path, @content = import_path, content
-  end
-
-  def import(client)
-    raise NotImplementedError, "#{self.class.name} needs to implement `#import`"
-  end
-
-  def to_s
-    import_path
-  end
-
-  def content_as_object
-    return content unless content.is_a?(String)
-    LogStash::Json.load(content) rescue nil
-  end
-end end end

data/lib/logstash/modules/kibana_client.rb

@@ -1,124 +0,0 @@
-# encoding: utf-8
-require "logstash/namespace"
-require "logstash/logging"
-require "logstash/json"
-require "manticore/client"
-
-module LogStash module Modules class KibanaClient
-  include LogStash::Util::Loggable
-
-  class Response
-    # to create a custom response with body as an Object (Hash or Array)
-    attr_reader :status, :body, :headers
-    def initialize(status, body, headers={})
-      @status, @body, @headers = status, body, headers
-      @body = body.is_a?(String) ? LogStash::Json.load(body) : body
-    end
-
-    def succeeded?
-      @status >= 200 && @status < 300
-    end
-
-    def failed?
-      !succeeded?
-    end
-  end
-
-  attr_reader :version
-
-  def initialize(settings)
-    @settings = settings
-
-    client_options = {
-      request_timeout: 5,
-      connect_timeout: 5,
-      socket_timeout: 5,
-      pool_max: 10,
-      pool_max_per_route: 2
-    }
-
-    ssl_options = {}
-
-    if @settings["var.kibana.ssl.enabled"] == "true"
-      ssl_options[:verify] = @settings.fetch("var.kibana.ssl.verification_mode", "strict").to_sym
-      ssl_options[:ca_file] = @settings.fetch("var.kibana.ssl.certificate_authority", nil)
-      ssl_options[:client_cert] = @settings.fetch("var.kibana.ssl.certificate", nil)
-      ssl_options[:client_key] = @settings.fetch("var.kibana.ssl.key", nil)
-    end
-
-    client_options[:ssl] = ssl_options
-
-    @client = Manticore::Client.new(client_options)
-    @host = @settings.fetch("var.kibana.host", "localhost:5601")
-    username = @settings["var.kibana.username"]
-    password = @settings["var.kibana.password"]
-
-    @scheme = @settings.fetch("var.kibana.scheme", "http")
-    @http_options = {:headers => {'Content-Type' => 'application/json'}}
-    if username
-      @http_options[:headers]['Authorization'] = 'Basic ' + Base64.encode64( "#{username}:#{password}" ).chomp
-    end
-
-    # e.g. {"name":"Elastics-MacBook-Pro.local","version":{"number":"6.0.0-alpha3","build_hash":"41e69","build_number":15613,"build_snapshot":true}..}
-    @version = "0.0.0"
-    response = get("api/status")
-    if response.succeeded?
-      status = response.body
-      if status["version"].is_a?(Hash)
-        @version = status["version"]["number"]
-        if status["version"]["build_snapshot"]
-          @version.concat("-SNAPSHOT")
-        end
-      else
-        @version = status["version"]
-      end
-    end
-    @http_options[:headers]['kbn-version'] = @version
-  end
-
-  def version_parts
-    @version.split(/\.|\-/)
-  end
-
-  def host_settings
-    "[\"#{@host}\"]"
-  end
-
-  def get(relative_path)
-    # e.g. api/kibana/settings
-    safely(:get, relative_path, @http_options)
-  end
-
-  # content will be converted to a json string
-  def post(relative_path, content, headers = nil)
-
-    body = content.is_a?(String) ? content : LogStash::Json.dump(content)
-    options = {:body => body}.merge(headers || @http_options)
-    safely(:post, relative_path, options)
-  end
-
-  def head(relative_path)
-    safely(:head, relative_path, @http_options)
-  end
-
-  def can_connect?
-    head("api/status").succeeded?
-  end
-
-  private
-
-  def safely(method_sym, relative_path, options = {})
-    begin
-      resp = @client.http(method_sym, full_url(relative_path), options).call
-      Response.new(resp.code, resp.body, resp.headers)
-    rescue Manticore::ManticoreException => e
-      logger.error("Error when executing Kibana client request", :error => e)
-      body = {"statusCode" => 0, "error" => e.message}
-      Response.new(0, body, {})
-    end
-  end
-
-  def full_url(relative)
-    "#{@scheme}://#{@host}/#{relative}"
-  end
-end end end

data/lib/logstash/modules/kibana_config.rb

@@ -1,105 +0,0 @@
-# encoding: utf-8
-require "logstash/namespace"
-require "logstash/logging"
-
-require_relative "file_reader"
-require_relative "kibana_settings"
-require_relative "kibana_dashboards"
-require_relative "kibana_resource"
-
-module LogStash module Modules class KibanaConfig
-  include LogStash::Util::Loggable
-
-  ALLOWED_DIRECTORIES = ["search", "visualization"]
-  attr_reader :index_name # not used when importing via kibana but for BWC with ElastsearchConfig
-
-  # We name it `modul` here because `module` has meaning in Ruby.
-  def initialize(modul, settings)
-    @directory = ::File.join(modul.directory, "kibana")
-    @name = modul.module_name
-    @settings = settings
-    @index_name = "kibana"
-    @pattern_name = "#{@name}-*"
-    @kibana_settings = [
-      KibanaSettings::Setting.new("defaultIndex", @pattern_name)
-    ]
-  end
-
-  def dashboards
-    # there can be more than one dashboard to load
-    filenames = FileReader.read_json(dynamic("dashboard"))
-    filenames.map do |filename|
-      KibanaResource.new(@index_name, "dashboard", dynamic("dashboard", filename))
-    end
-  end
-
-  def index_pattern
-    [KibanaResource.new(@index_name, "index-pattern", dynamic("index-pattern"),nil, @pattern_name)]
-  end
-
-  def resources
-    list = index_pattern
-    dashboards.each do |board|
-      list << board
-      extract_panels_into(board, list)
-    end
-    list.concat(extract_saved_searches_into(list))
-    [
-      KibanaSettings.new("api/kibana/settings", @kibana_settings),
-      KibanaDashboards.new("api/kibana/dashboards/import", list)
-    ]
-  end
-
-  private
-
-  def dynamic(dynamic_folder, filename = @name)
-    ::File.join(@directory, dynamic_folder, "#{filename}.json")
-  end
-
-  def extract_panels_into(dashboard, list)
-    dash = dashboard.content_as_object
-
-    if !dash.is_a?(Hash)
-      logger.warn("Kibana dashboard JSON is not an Object", :module => @name)
-      return
-    end
-
-    panelsjson = dash["panelsJSON"]
-
-    if panelsjson.nil?
-      logger.info("No panelJSON key found in kibana dashboard", :module => @name)
-      return
-    end
-
-    begin
-      panels = LogStash::Json.load(panelsjson)
-    rescue => e
-      logger.error("JSON parse error when reading kibana panelsJSON", :module => @name)
-      return
-    end
-
-    panels.each do |panel|
-      panel_type = panel["type"]
-      if ALLOWED_DIRECTORIES.member?(panel_type)
-        list << KibanaResource.new(@index_name, panel_type, dynamic(panel_type, panel["id"]))
-      else
-        logger.warn("panelJSON contained unknown type", :type => panel_type)
-      end
-    end
-  end
-
-  def extract_saved_searches_into(list)
-    result = [] # must not add to list while iterating
-    list.each do |resource|
-      content = resource.content_as_object
-      next if content.nil?
-      next unless content.keys.include?("savedSearchId")
-      saved_search = content["savedSearchId"]
-      next if saved_search.nil?
-      ss_resource = KibanaResource.new(@index_name, "search", dynamic("search", saved_search))
-      next if list.member?(ss_resource) || result.member?(ss_resource)
-      result << ss_resource
-    end
-    result
-  end
-end end end