How to Write Base Plugin
All plugin types are subclasses of
Fluent::Plugin::Base
in Fluentd v1 or later. The Base
class has some features and methods that provide the basic mechanism as plugins. This page shows these methods provided by Fluent::Plugin::Base
, and other methods provided commonly in some type of plugins.The methods listed below are considered as public methods, and will be maintained not to break compatibility. Other methods may be changed without compatibility consideration.
require 'fluent/plugin/input' # This may be input, filter, output, parser, formatter, storage or buffer.
module Fluent::Plugin
class MyExampleInput < Input
# Plugins should be registered by calling `Fluent::Plugin.register_TYPE` method with name and `self`.
# The first argument String is to identify the plugin in the configuration file.
# The second argument is class of the plugin itself, `self` in most cases.
Fluent::Plugin.register_input('my_example', self)
desc 'The port number'
# `config_param` Defines a parameter. You can refer the following parameter via @port instance variable.
# Without `:default`, a parameter is required.
config_param :port, :integer
config_section :user, param_name: :users, multi: true, required: false do
desc 'Username for authentication'
config_param :username, :string
desc 'Password for authentication'
config_param :password, :string, secret: true
end
def configure(conf)
super
# If the configuration is invalid, raise `Fluent::ConfigError`.
if @port <= 1024
raise Fluent::ConfigError, "port number is too small: #{@port}"
end
@users.each do |user|
if user.password.length < 5
raise Fluent::ConfigError, "password is too short for user '#{user.username}'"
end
end
end
def start
super
# ...
end
def shutdown
# ...
super
end
end
end
Base
class provides methods to create configurable parameters for plugins. It also supports methods to provide system configurations to plugins.Defines a parameter.
name
: the parameter name as a symboltype
: the parameter typeoptions
: the options for the parameterblock
: if given, convert the value via the given block
Code Example:
config_param :name, :string, default: 'John Doe', alias: :full_name
config_param :pattern do |value|
Regexp.compile(value)
end
config_param :delimiter, default: "\t" do |value|
case value
when /SPACE/i then ' '
when /COMMA/i then ','
else "\t"
end
end
Sets the default value of the parameter specified by
name
. If the default value already exists, it raises ArgumentError
.name
: The name of the parameter.default_value
: Default value of the parameter.
Code Example:
# lib/fluent/plugin/buffer.rb
config_param :chunk_limit_size, :size, default: DEFAULT_CHUNK_LIMIT_SIZE
# lib/fluent/plugin/buf_file.rb
config_set_default :chunk_limit_size, DEFAULT_CHUNK_LIMIT_SIZE
Sets description of the parameter specified by
name
. If the description already exists, it raises ArgumentError
. For internal use only! Use desc
instead.name
: The name of the parameter.description
: Description of the parameter.
Sets description of the immediately following parameter.
description
: Description of the parameter.
Code Example:
desc 'The username'
config_param :user, :string
Defines a section to construct structured (nested) configuration.
name
: The name of the section.options
:root
: Iftrue
, this section is the root section. For internal use only!param_name
: The section name.final
: Iftrue
, the subclass of this class cannot override this section.For example, the third0party plugins cannot override the buffer section.init
: Iftrue
, the parameters in this section must have default values.Not applicable to third-party plugins.required
: Iftrue
, the section is required. Fluentd will raiseFluent::ConfigError
if the section is missing.multi
: Iftrue
, users can configure this section multiple times.alias
: Alias for this section.
Code Example:
config_section :user, multi: true do
config_param :name, :string
config_param :password, :string, secret: true
end
# nested sections
config_section :child, :param_name: 'children', required: false, multi: true do
config_param :name, :string
config_param :power, :integer, default: nil
config_section :item, multi: true do
config_param :name, :string
config_param :flavor, :string
end
end
Configuration Example:
<user>
name Alice
password very-secret-password
</user>
# nested sections
<child>
name Bob
power 1000
<item>
name potion
flavor very sour orange
</item>
<item>
name gumi
flavor super delicious apple
</item>
</child>
Inherits section
section_name
defined in the super class.section_name
: The section name as Symbol.
Returns
Fluent::SystemConfig
instance.Code Example:
def configure(conf)
super
root_dir = system_config.root_dir
end
Overrides the system configuration.
This is for internal use and plugin testing.
options
: The system configuration as Hash.
Code Example:
test 'plugin instance can overwrite system_config if needed' do
plugin = ExampleInput.new
plugin.configure(conf)
# ...
plugin.system_config_override('workers' => 3)
# ...
end
Initializes the internal states (instance variables).
Call
super
if the plugin overrides this method.Code Example:
def initialize
super
@internal_counter = 0
@in_memory_cache = nil
end
The
conf
parameter is an instance of Fluent::Config::Element
. Call super
if the plugin overrides this method. Fluentd's Configurable module (included in Base class) will traverse conf
object, and set values from configurations or default values into the instance variables in super
. So, the instance variables or accessor methods are available after super
in #configure
method.The code to configure the plugin should be after
super
.Code Example:
def configure(conf)
super
# cache_default_value is created/configured by config_param
@in_memory_cache = Hash.new(@cache_default_value)
end
NOTE: The return value of this method will be ignored.
Returns
Fluent::Log
instance.Log levels:
trace
debug
info
warn
error
fatal
Code Example:
def start
# ...
log.info('This is info level log')
# Evaluate only if log level is trace
log.trace do
# Heavy calculation to trace plugin behavior
'This is trace level log'
end
end
Indicates whether the
#router
method exists or not. (default: false
)If the plugin uses
event_emitter
plugin helper, this method will return true
.NOTE: Input plugin enables
event_emitter
by default.This method is automatically called when Fluentd starts after the configuration. Call
super
if the plugin overrides this method.Creating/opening timers, threads, listening sockets, file handles and others should be done in this method after
super
. Many of these may be provided as plugin helpers. See API details of each plugin helper.Code Example:
def start
super
timer_execute(:my_example_timer, 30) do
# Code that will be executed every 30 seconds
end
end
This method is automatically called first in the shutdown sequence of Fluentd. It should be used to manipulate flags to stop loops, e.g. network servers, gracefully. This method SHOULD NOT do anything that may raise errors.
Call
super
if the plugin overrides this method.Code Example:
def start
super
@my_thread_running = true
@my_thread = thread_create(:example_code) do
if @my_thread_running
log.debug 'loop is running'
end
end
end
def stop
@my_thread_running = false
super
end
super
should be called at last in methods of shutdown sequence: stop
, before_shutdown
, shutdown
, after_shutdown
, close
and terminate
.This method is automatically called after
#stop
and before #shutdown
. It may be used to control the flushing of buffered events in the shutdown sequence.Call
super
if the plugin overrides this method. The third-party plugins do not need to implement this method in most cases.This method is automatically called while shutting down. It may be used to close file handles, network connections, listening servers, and other resources that need cleanup. The event can be emitted in this method but not after this method is called.
Call
super
if the plugin overrides this method.Code Example:
def shutdown
@server.close
records = my_convert_method(@server.rest_data)
records.each do |record|
router.emit(@tag, Fluent::Engine.now, record)
end
super
end
This method is automatically called after
#shutdown
. It is used to control the emitting of events in shutdown sequence.Call
super
if the plugin overrides this method. Third-party plugins do not need to implement this method in most cases.This method may be used to close those resources that cannot be closed in
#shutdown
.Call
super
if the plugin overrides this method.This method may be used to re-initialize the internal states for the reuse of plugin instances in tests, etc.
Call
super
if the plugin overrides this method.Following methods are available in the subclass of Input, Filter and Output:
Includes the features of the plugin helpers.
Code Example:
module Fluent::Plugin
class MyPlugin < Input
Fluent::Plugin.register_input('my_plugin', self)
# This call enables Timer and Storage plugin helpers
helpers :timer, :storage
# ...
end
end
It is strongly recommended to call this method at the top of the plugin class definition (just after calling
#register_
) to show what plugin helpers this plugin uses explicitly.Provides a unique ID string for the plugin instance. It might be specified by users in the configuration files, or generated automatically. The plugin must not expect any fixed formats for its return value.
Indicates whether
#plugin_id
is configured by users or not.If this article is incorrect or outdated, or omits critical information, please let us know. Fluentd is an open-source project under Cloud Native Computing Foundation (CNCF). All components are available under the Apache 2 License.
Last modified 2yr ago