redis-list-source-fluentd 1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d1641d4cbbe1ba29475a656404eb224da18acd4c710ea63e0df8dbff97f3b238
+  data.tar.gz: 342a0fad90b2493c092c80d12ccfebe99d37340b14006a42bcb214ebfe967d4a
+SHA512:
+  metadata.gz: b3b91f93a3f857b1493f983d43017c6a36c1b63515a9f1650c95c43a5222a3113190d50b62b0786babeabc048e613153ce56698d304f58728714414764c47bb0
+  data.tar.gz: 6f00253cfc030868b5c4a579afc411d5244031dc2d02fc64b7703fd1c7b81fd886914434cabc872a49e06e39d767982e67cc38f105fcf215a0ecce61a6209a57

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.gem

data/README.md

@@ -0,0 +1,41 @@
+# Fluent::Plugin::RedisListPoller
+
+This gem will help you to connect redis and fluentd. With it you'll be able to get your data from redis with fluentd.
+
+## Requirements
+
+* Fluentd v0.14+
+
+## Installation
+
+```bash
+gem install fluent-plugin-redis_list_poller
+```
+
+## Configuration Options
+
+```
+<source>
+  @type       redis_listener
+  host        127.0.0.1
+  port        6379
+  password    nil
+  db          0
+  timeout     5.0
+  driver      ruby
+
+  key         redis_list_item
+  command     lpop
+  batch_size  100
+
+  tag         redis.data
+
+  poll_interval      0.01
+  sleep_interval     5
+  retry_interval    5
+
+  <parse>
+    @type json
+  </parse>
+</source>
+```

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "aargh"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/fluent/plugin/in_redis_list_monitor.rb

@@ -0,0 +1,133 @@
+require "fluent/plugin/input"
+require "fluent/plugin_mixin/redis"
+
+module Fluent
+  module Plugin
+    # Input plugin which will monitor the size of a redis list and periodically
+    # output metrics to the login pipeline.
+    # @since 0.1.0
+    class RedisListMonitorInput < Input
+      Plugin.register_input('redis_list_monitor', self)
+      
+      include Fluent::PluginMixin::Redis
+      helpers :timer
+
+      # input plugin parameters
+      config_param :tag,      :string,  :default => nil
+
+      # Initialize new input plugin
+      # @since 0.1.0
+      # @return [NilClass]
+      def initialize
+        super
+      end
+
+      # Initialize attributes and parameters
+      # @since 0.1.0
+      # @return [NilClass]
+      def configure(config)
+        super
+
+        configure_params(config)
+        configure_locking(config)
+
+        @queue_length = 0
+        @retry_at     = nil
+      end
+
+      # Configure plugin parameters
+      # @since 0.1.0
+      # @return [NilClass]
+      def configure_params(config)
+        %w(host port key tag).each do |key|
+          next if instance_variable_get("@#{key}")
+          raise Fluent::ConfigError, "configuration key missing: #{key}"
+        end
+      end
+
+      # Configure locking
+      # @since 0.1.0
+      # @return [NilClass]
+      def configure_locking(config)
+        @storage  = storage_create(type: 'local')
+        @lock_key = "redis:#{@key}:lock"
+      end
+
+      # Prepare the plugin event loop
+      #
+      # This method will initialize the Redis connection object, create any required Redis structures as well
+      # as define and begin the event pollers.
+      #
+      # @since 0.1.0
+      # @return [NilClass]
+      def start
+        super
+
+        start_redis
+        start_poller
+      end
+
+      def start_poller
+        timer_execute(:poll, @poll_interval) do
+          action_poll
+        end
+      end
+
+      # Tear down the plugin
+      # @since 0.1.0
+      # @return [NilClass]
+      def shutdown
+        super
+        shutdown_redis
+      end
+
+      # Wether the poller has been temporarily disabled or should fetch messages
+      # been temporarily disabled
+      # @since 0.1.0
+      # @return [TrueClass, FalseClass]
+      def sleeping?
+        @retry_at and @retry_at >= Engine.now
+      end
+
+      # Set a sleep delay, ensuring that we will not attempt to fetch messages
+      # @since 0.1.0
+      # @param [Integer] delay, the amount of seconds to wait
+      # @return [Integer] timestamp when this expires
+      def sleep!(delay = @sleep_interval)
+        @retry_at = Engine.now + delay
+      end
+
+      # Action to execute when the monitor event watcher executes
+      #
+      # The monitor is simply responsible for outputting the queue length to 
+      # the logs as well as detecting zero length lists. 
+      #
+      # @since 0.1.0
+      # @return [NilClass]
+      def action_poll
+        now = Engine.now
+
+        if sleeping?
+          log.trace "redis worker is sleeping"
+          return
+        end
+
+        list_size = @redis.llen(@key)
+
+        event = {
+          "timestamp" => now,
+          "message" => "redis queue monitor",
+          "hostname" => @host,
+          "key" => @key,
+          "size" => list_size
+        }
+
+        router.emit @tag, now, event
+      rescue => e
+        log.error "error monitoring queue", :error => e
+        log.error_backtrace
+        sleep!(@retry_interval)
+      end
+    end
+  end
+end

data/lib/fluent/plugin/in_redis_list_poller.rb

@@ -0,0 +1,237 @@
+require "fluent/plugin/input"
+require "fluent/plugin/parser"
+require 'fluent/process'
+require "fluent/plugin_mixin/redis"
+
+module Fluent
+  module Plugin
+    class RedisListPollerInput < Input
+      include Fluent::PluginMixin::Redis
+
+      Plugin.register_input('redis_listener', self)
+      helpers :storage
+      helpers :timer
+
+      # redis list details
+      # - command: redis command to execute when fetching messages
+      # - batch_size: if greater than 0, fetch messages in batches
+      config_param :command,    :string,  :default => "lpop"
+      config_param :batch_size, :integer, :default => 0
+
+      # input plugin parameters
+      config_param :tag,      :string,  :default => nil
+
+      # parser plugin parameters
+      config_section :parse, :init => true, :multi => false do
+        config_set_default :@type, "json"
+      end
+
+      # Initialize new input plugin
+      # @since 0.1.0
+      # @return [NilClass]
+      def initialize
+        super
+        require 'msgpack'
+      end
+
+      # Initialize attributes and parameters
+      # @since 0.1.0
+      # @return [NilClass]
+      def configure(config)
+        super
+
+        configure_params(config)
+        configure_parser(config)
+        configure_locking(config)
+
+        @retry_at     = nil
+      end
+
+      # Configure plugin parameters
+      # @since 0.1.0
+      # @return [NilClass]
+      def configure_params(config)
+        %w(host port key command tag).each do |key|
+          next if instance_variable_get("@#{key}")
+          raise Fluent::ConfigError, "configuration key missing: #{key}"
+        end
+
+        unless %w(lpop rpop).include?(@command)
+          raise Fluent::ConfigError, "command must be either lpop or rpop"
+        end
+      end
+
+      # Configure record parser
+      # @since 0.1.0
+      # @return [NilClass]
+      def configure_parser(config)
+        parser_config = @parse.corresponding_config_element
+        parser_type = parser_config['@type']
+        @parser = Fluent::Plugin.new_parser(parser_type, :parent => self)
+        @parser.configure(parser_config)
+      end
+
+      # Configure locking
+      # @since 0.1.0
+      # @return [NilClass]
+      def configure_locking(config)
+        @storage  = storage_create(type: 'local')
+        @lock_key = "fluentd:#{@key}:lock"
+      end
+
+      # Prepare the plugin event loop
+      #
+      # This method will initialize the Redis connection object, create any required Redis structures as well
+      # as define and begin the event pollers.
+      #
+      # @since 0.1.0
+      # @return [NilClass]
+      def start
+        super
+        start_redis
+        start_poller
+        start_monitor
+      end
+
+      # Prepare the Redis queue poller
+      #
+      # This timed event will routinely poll items from the Redis list and
+      # emit those through the pipeline.
+      #
+      # @since 0.1.0
+      # @return [NilClass]
+      def start_poller
+        timer_execute(:poller, @poll_interval) do
+          action_poll
+        end
+      end
+
+      # Prepare the Redis queue monitor
+      #
+      # This timed event will routinely poll for a lock key and disable the
+      # queue poller if required
+      #
+      # @since 0.1.1
+      # @return [NilClass]
+      def start_monitor
+        timer_execute(:monitor, 1) do
+          action_locking_monitor
+        end
+      end
+
+      # Tear down the plugin
+      # @since 0.1.0
+      # @return [NilClass]
+      def shutdown
+        super
+        shutdown_redis
+      end
+
+      # Whether to fetch a single item or a multiple items in batch
+      # @since 0.1.0
+      # @return [TrueClass, FalseClass]
+      def batched?
+        @batch_size and @batch_size > 1
+      end
+
+      # Wether the poller has been temporarily disabled or should fetch messages
+      # been temporarily disabled
+      # @since 0.1.0
+      # @return [TrueClass, FalseClass]
+      def sleeping?
+        @retry_at and @retry_at >= Engine.now
+      end
+
+      # Whether the poller has been locked
+      # @since 0.1.0
+      # @return [TrueClass, FalseClass]
+      def locked?
+        @storage.get(@lock_key)
+      end
+
+      # Set a sleep delay, ensuring that we will not attempt to fetch messages
+      # @since 0.1.0
+      # @param [Integer] delay, the amount of seconds to wait
+      # @return [Integer] timestamp when this expires
+      def sleep!(delay = @sleep_interval)
+        @retry_at = Engine.now + delay
+      end
+
+      # Poll messages from the redis server in either single message or 
+      # batch mode.
+      # @since 0.1.0
+      # @param [&block] the block to yield single messages to
+      # @return [NilClass]
+      def poll_messages
+        commands = []
+
+        if batched?
+          @redis.pipelined do
+            @batch_size.times do
+              commands << @redis.call(@command, @key)
+            end
+          end
+        else
+          commands << @redis.call(@command, @key)
+        end
+
+        commands.each do |command|
+          yield command.is_a?(Redis::Future) ? command.value : command
+        end
+      end
+
+      # Action to execute when polling for the lock key
+      # @since 0.1.0
+      # @return [NilClass]
+      def action_locking_monitor
+        lock_value = @redis.get(@lock_key)
+        @storage.put(@lock_key, lock_value)
+      end
+
+      # Action to execute when the poller event watcher executes
+      #
+      # Given that the watcher is pretty lightweight, we simply return if the
+      # worker has been set to sleep instead of actually sleeping. Doing
+      # otherwise seemed to cause locking.
+      #
+      # Otherwise we iterate through messages, parse and emit them. 
+      #
+      # @since 0.1.0
+      # @return [NilClass]
+      def action_poll
+        now = Engine.now
+        messages = []
+
+        if sleeping?
+          log.trace "redis worker is sleeping"
+          return
+        end
+
+        if locked?
+          log.trace "redis queue is locked"
+          return
+        end
+
+        poll_messages do |message|
+          if message.nil?
+            log.debug "redis queue is empty"
+            sleep!(@sleep_interval)
+            break
+          end
+
+          @parser.parse(message) do |time, record|
+            if time && record
+              router.emit @tag || @key, time || Engine.now, record
+            else
+              log.warn "failed to parse message: #{message}"
+            end
+          end
+        end
+      rescue => e
+        log.error "error fetching record", :error => e
+        log.error_backtrace
+        sleep!(@retry_interval)
+      end
+    end
+  end
+end

data/lib/fluent/plugin_mixin/redis.rb

@@ -0,0 +1,66 @@
+
+module Fluent
+  module PluginMixin
+    module Redis
+      def self.included(base)
+        base.class_eval do
+          # redis connection details
+          config_param :host,     :string,  :default => '127.0.0.1'
+          config_param :port,     :integer, :default => 6379
+          config_param :path,     :string,  :default => nil
+          config_param :password, :string,  :default => nil
+          config_param :db,       :integer, :default => 0
+          config_param :timeout,  :float,   :default => 5.0
+          config_param :driver,   :string,  :default => "ruby"
+
+          # redis list details
+          # - key: redis key of type `list` to fetch messages from
+          # - command: redis command to execute when fetching messages
+          # - batch_size: if greater than 0, fetch messages in batches
+          config_param :key, :string, :default => nil
+
+          # worker parameters
+          # - poll_inteval: interval between message polling actions
+          #                 *NOTE*: Apparently this must be greather than 0
+          # - sleep_interval: interval to wait after receiving 0 messages
+          # - retry_interval: interval to wait before retrying after an error
+          config_param :poll_interval,    :float, :default => 1
+          config_param :sleep_interval,   :float, :default => 5
+          config_param :retry_interval,   :float, :default => 5
+
+          attr_reader  :redis
+        end
+      end
+
+      # Initialize new input plugin
+      # @since 0.1.0
+      # @return [NilClass]
+      def initialize
+        require 'redis'
+        super
+      end
+
+      # Prepare the Redis conncection object
+      # @since 0.1.0
+      # @return [Redis]
+      def start_redis
+        @redis  = ::Redis.new(
+          :host => @host,
+          :port => @port,
+	  :db   => @db,
+          :driver => @driver,
+	  :timeout => @timeout,
+          :password => @password,
+          :thread_safe => true
+        )
+      end
+
+      # Destroy the Redis connection object
+      # @since 0.1.0
+      # @return [NilClass]
+      def shutdown_redis
+        @redis.quit
+      end
+    end
+  end
+end

data/redis-to-fluentd-listener.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+
+Gem::Specification.new do |spec|
+  spec.name          = 'redis-list-source-fluentd'
+  spec.version       = '1.0'
+  spec.authors       = ['Nikita Kazeichev']
+  spec.email         = ['kazeichev@yandex.ru']
+
+  spec.summary       = 'Plugin wich help you to transfer data from redis to fluentd'
+  spec.description   = 'This gem will help you to connect redis and fluentd. With it you\'ll be able to get your data from redis with fluentd.'
+  spec.homepage      = 'https://github.com/kazeichev/fluent-plugin-redis_list_poller'
+  spec.license       = '0BSD'
+
+  spec.files         = `git ls-files -z`
+                       .split("\x0")
+                       .reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.executables   = []
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake'
+
+  spec.add_runtime_dependency 'redis', ['>= 3.3.0', '< 3.4.0']
+  spec.add_runtime_dependency 'fluentd', ['>= 0.14.0', '< 2']
+end

metadata

@@ -0,0 +1,121 @@
+--- !ruby/object:Gem::Specification
+name: redis-list-source-fluentd
+version: !ruby/object:Gem::Version
+  version: '1.0'
+platform: ruby
+authors:
+- Nikita Kazeichev
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-05-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.3.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 3.4.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.3.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 3.4.0
+- !ruby/object:Gem::Dependency
+  name: fluentd
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.14.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.14.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
+description: This gem will help you to connect redis and fluentd. With it you'll be
+  able to get your data from redis with fluentd.
+email:
+- kazeichev@yandex.ru
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- README.md
+- bin/console
+- bin/setup
+- lib/fluent/plugin/in_redis_list_monitor.rb
+- lib/fluent/plugin/in_redis_list_poller.rb
+- lib/fluent/plugin_mixin/redis.rb
+- redis-to-fluentd-listener.gemspec
+homepage: https://github.com/kazeichev/fluent-plugin-redis_list_poller
+licenses:
+- 0BSD
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Plugin wich help you to transfer data from redis to fluentd
+test_files: []