in logstash-core/src/main/java/org/logstash/RubyUtil.java [250:586]
static {
RUBY = Ruby.getGlobalRuntime();
LOGSTASH_MODULE = RUBY.getOrCreateModule("LogStash");
Stream.of(
"Inputs", "Outputs", "Filters", "Search", "Config", "File", "Web", "PluginMixins",
"PluginManager", "Api", "Modules"
).forEach(module -> RUBY.defineModuleUnder(module, LOGSTASH_MODULE));
PLUGINS_MODULE = RUBY.defineModuleUnder("Plugins", LOGSTASH_MODULE);
final RubyModule instrumentModule =
RUBY.defineModuleUnder("Instrument", LOGSTASH_MODULE);
METRIC_SNAPSHOT_CLASS =
instrumentModule.defineClassUnder("Snapshot", RUBY.getObject(), SnapshotExt::new);
METRIC_SNAPSHOT_CLASS.defineAnnotatedMethods(SnapshotExt.class);
EXECUTION_CONTEXT_FACTORY_CLASS = PLUGINS_MODULE.defineClassUnder(
"ExecutionContextFactory", RUBY.getObject(),
ExecutionContextFactoryExt::new
);
PLUGIN_METRICS_FACTORY_CLASS = PLUGINS_MODULE.defineClassUnder(
"PluginMetricsFactory", RUBY.getObject(), PluginMetricsFactoryExt::new
);
SHUTDOWN_WATCHER_CLASS =
setupLogstashClass(ShutdownWatcherExt::new, ShutdownWatcherExt.class);
PLUGIN_METRICS_FACTORY_CLASS.defineAnnotatedMethods(PluginMetricsFactoryExt.class);
EXECUTION_CONTEXT_FACTORY_CLASS.defineAnnotatedMethods(
ExecutionContextFactoryExt.class
);
METRIC_EXCEPTION_CLASS = instrumentModule.defineClassUnder(
"MetricException", RUBY.getException(), MetricExt.MetricException::new
);
METRIC_NO_KEY_PROVIDED_CLASS = instrumentModule.defineClassUnder(
"MetricNoKeyProvided", METRIC_EXCEPTION_CLASS, MetricExt.MetricNoKeyProvided::new
);
METRIC_NO_BLOCK_PROVIDED_CLASS = instrumentModule.defineClassUnder(
"MetricNoBlockProvided", METRIC_EXCEPTION_CLASS,
MetricExt.MetricNoBlockProvided::new
);
METRIC_NO_NAMESPACE_PROVIDED_CLASS = instrumentModule.defineClassUnder(
"MetricNoNamespaceProvided", METRIC_EXCEPTION_CLASS,
MetricExt.MetricNoNamespaceProvided::new
);
ABSTRACT_METRIC_CLASS = instrumentModule.defineClassUnder(
"AbstractMetric", RUBY.getObject(),
ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR
);
ABSTRACT_NAMESPACED_METRIC_CLASS = instrumentModule.defineClassUnder(
"AbstractNamespacedMetric", ABSTRACT_METRIC_CLASS,
ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR
);
ABSTRACT_SIMPLE_METRIC_CLASS = instrumentModule.defineClassUnder(
"AbstractSimpleMetric", ABSTRACT_METRIC_CLASS,
ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR
);
METRIC_CLASS = instrumentModule.defineClassUnder(
"Metric", ABSTRACT_SIMPLE_METRIC_CLASS, MetricExt::new
);
NULL_METRIC_CLASS = instrumentModule.defineClassUnder(
"NullMetric", ABSTRACT_SIMPLE_METRIC_CLASS, NullMetricExt::new
);
TIMED_EXECUTION_CLASS = METRIC_CLASS.defineClassUnder(
"TimedExecution", RUBY.getObject(), MetricExt.TimedExecution::new
);
NULL_TIMED_EXECUTION_CLASS = NULL_METRIC_CLASS.defineClassUnder(
"NullTimedExecution", RUBY.getObject(), NullMetricExt.NullTimedExecution::new
);
NULL_COUNTER_CLASS = METRIC_CLASS.defineClassUnder(
"NullCounter", RUBY.getObject(), NullNamespacedMetricExt.NullCounter::new
);
NAMESPACED_METRIC_CLASS = instrumentModule.defineClassUnder(
"NamespacedMetric", ABSTRACT_NAMESPACED_METRIC_CLASS, NamespacedMetricExt::new
);
NULL_NAMESPACED_METRIC_CLASS = instrumentModule.defineClassUnder(
"NamespacedNullMetric", ABSTRACT_NAMESPACED_METRIC_CLASS,
NullNamespacedMetricExt::new
);
ABSTRACT_METRIC_CLASS.defineAnnotatedMethods(AbstractMetricExt.class);
ABSTRACT_SIMPLE_METRIC_CLASS.defineAnnotatedMethods(AbstractSimpleMetricExt.class);
ABSTRACT_NAMESPACED_METRIC_CLASS.defineAnnotatedMethods(AbstractNamespacedMetricExt.class);
METRIC_CLASS.defineAnnotatedMethods(MetricExt.class);
NULL_METRIC_CLASS.defineAnnotatedMethods(NullMetricExt.class);
NAMESPACED_METRIC_CLASS.defineAnnotatedMethods(NamespacedMetricExt.class);
NULL_NAMESPACED_METRIC_CLASS.defineAnnotatedMethods(NullNamespacedMetricExt.class);
TIMED_EXECUTION_CLASS.defineAnnotatedMethods(MetricExt.TimedExecution.class);
NULL_TIMED_EXECUTION_CLASS.defineAnnotatedMethods(NullMetricExt.NullTimedExecution.class);
NULL_COUNTER_CLASS.defineAnnotatedMethods(NullNamespacedMetricExt.NullCounter.class);
UTIL_MODULE = LOGSTASH_MODULE.defineModuleUnder("Util");
UTIL_MODULE.defineAnnotatedMethods(UtilExt.class);
ABSTRACT_DLQ_WRITER_CLASS = UTIL_MODULE.defineClassUnder(
"AbstractDeadLetterQueueWriter", RUBY.getObject(),
ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR
);
ABSTRACT_DLQ_WRITER_CLASS.defineAnnotatedMethods(AbstractDeadLetterQueueWriterExt.class);
DUMMY_DLQ_WRITER_CLASS = UTIL_MODULE.defineClassUnder(
"DummyDeadLetterQueueWriter", ABSTRACT_DLQ_WRITER_CLASS,
AbstractDeadLetterQueueWriterExt.DummyDeadLetterQueueWriterExt::new
);
DUMMY_DLQ_WRITER_CLASS.defineAnnotatedMethods(
AbstractDeadLetterQueueWriterExt.DummyDeadLetterQueueWriterExt.class
);
PLUGIN_DLQ_WRITER_CLASS = UTIL_MODULE.defineClassUnder(
"PluginDeadLetterQueueWriter", ABSTRACT_DLQ_WRITER_CLASS,
AbstractDeadLetterQueueWriterExt.PluginDeadLetterQueueWriterExt::new
);
PLUGIN_DLQ_WRITER_CLASS.defineAnnotatedMethods(
AbstractDeadLetterQueueWriterExt.PluginDeadLetterQueueWriterExt.class
);
OUTPUT_STRATEGY_REGISTRY = setupLogstashClass(
OutputStrategyExt.OutputStrategyRegistryExt::new,
OutputStrategyExt.OutputStrategyRegistryExt.class
);
BUFFERED_TOKENIZER = RUBY.getOrCreateModule("FileWatch").defineClassUnder(
"BufferedTokenizer", RUBY.getObject(), BufferedTokenizerExt::new
);
BUFFERED_TOKENIZER.defineAnnotatedMethods(BufferedTokenizerExt.class);
OUTPUT_DELEGATOR_STRATEGIES =
RUBY.defineModuleUnder("OutputDelegatorStrategies", LOGSTASH_MODULE);
OUTPUT_STRATEGY_ABSTRACT = OUTPUT_DELEGATOR_STRATEGIES.defineClassUnder(
"AbstractStrategy", RUBY.getObject(), ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR
);
OUTPUT_STRATEGY_SIMPLE_ABSTRACT = OUTPUT_DELEGATOR_STRATEGIES.defineClassUnder(
"SimpleAbstractStrategy", OUTPUT_STRATEGY_ABSTRACT,
ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR
);
OUTPUT_STRATEGY_LEGACY = OUTPUT_DELEGATOR_STRATEGIES.defineClassUnder(
"Legacy", OUTPUT_STRATEGY_ABSTRACT,
OutputStrategyExt.LegacyOutputStrategyExt::new
);
OUTPUT_STRATEGY_SINGLE = OUTPUT_DELEGATOR_STRATEGIES.defineClassUnder(
"Single", OUTPUT_STRATEGY_SIMPLE_ABSTRACT,
OutputStrategyExt.SingleOutputStrategyExt::new
);
OUTPUT_STRATEGY_SHARED = OUTPUT_DELEGATOR_STRATEGIES.defineClassUnder(
"Shared", OUTPUT_STRATEGY_SIMPLE_ABSTRACT,
OutputStrategyExt.SharedOutputStrategyExt::new
);
OUTPUT_STRATEGY_ABSTRACT.defineAnnotatedMethods(OutputStrategyExt.AbstractOutputStrategyExt.class);
OUTPUT_STRATEGY_ABSTRACT.defineAnnotatedMethods(OutputStrategyExt.SimpleAbstractOutputStrategyExt.class);
OUTPUT_STRATEGY_SHARED.defineAnnotatedMethods(OutputStrategyExt.SharedOutputStrategyExt.class);
OUTPUT_STRATEGY_SINGLE.defineAnnotatedMethods(OutputStrategyExt.SingleOutputStrategyExt.class);
OUTPUT_STRATEGY_LEGACY.defineAnnotatedMethods(OutputStrategyExt.LegacyOutputStrategyExt.class);
final OutputStrategyExt.OutputStrategyRegistryExt outputStrategyRegistry =
OutputStrategyExt.OutputStrategyRegistryExt.instance(
RUBY.getCurrentContext(), OUTPUT_DELEGATOR_STRATEGIES
);
outputStrategyRegistry.register(
RUBY.getCurrentContext(), RUBY.newSymbol("shared"), OUTPUT_STRATEGY_SHARED
);
outputStrategyRegistry.register(
RUBY.getCurrentContext(), RUBY.newSymbol("legacy"), OUTPUT_STRATEGY_LEGACY
);
outputStrategyRegistry.register(
RUBY.getCurrentContext(), RUBY.newSymbol("single"), OUTPUT_STRATEGY_SINGLE
);
EXECUTION_CONTEXT_CLASS = setupLogstashClass(
ExecutionContextExt::new, ExecutionContextExt.class
);
EXECUTION_CONTEXT_CLASS.defineConstant("Empty", EXECUTION_CONTEXT_CLASS.newInstance(RUBY.getCurrentContext(), RUBY.getNil(), RUBY.getNil(), RUBY.getNil(), Block.NULL_BLOCK));
RUBY_TIMESTAMP_CLASS = setupLogstashClass(
JrubyTimestampExtLibrary.RubyTimestamp::new, JrubyTimestampExtLibrary.RubyTimestamp.class
);
ABSTRACT_WRAPPED_QUEUE_CLASS = LOGSTASH_MODULE.defineClassUnder(
"AbstractWrappedQueue", RUBY.getObject(),
ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR
);
ABSTRACT_WRAPPED_QUEUE_CLASS.defineAnnotatedMethods(AbstractWrappedQueueExt.class);
ABSTRACT_WRITE_CLIENT_CLASS = LOGSTASH_MODULE.defineClassUnder(
"AbstractQueueWriteClient", RUBY.getObject(),
ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR
);
ABSTRACT_WRITE_CLIENT_CLASS.defineAnnotatedMethods(JRubyAbstractQueueWriteClientExt.class);
WRAPPED_WRITE_CLIENT_CLASS =
setupLogstashClass(JRubyWrappedWriteClientExt::new, JRubyWrappedWriteClientExt.class);
QUEUE_READ_CLIENT_BASE_CLASS =
setupLogstashClass(ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR, QueueReadClientBase.class);
MEMORY_READ_CLIENT_CLASS =
setupLogstashClass(QUEUE_READ_CLIENT_BASE_CLASS, JrubyMemoryReadClientExt::new, JrubyMemoryReadClientExt.class);
ACKED_READ_CLIENT_CLASS =
setupLogstashClass(QUEUE_READ_CLIENT_BASE_CLASS, JrubyAckedReadClientExt::new, JrubyAckedReadClientExt.class);
MEMORY_WRITE_CLIENT_CLASS = setupLogstashClass(
ABSTRACT_WRITE_CLIENT_CLASS, JrubyMemoryWriteClientExt::new,
JrubyMemoryWriteClientExt.class
);
ACKED_WRITE_CLIENT_CLASS = setupLogstashClass(
ABSTRACT_WRITE_CLIENT_CLASS, JrubyAckedWriteClientExt::new,
JrubyAckedWriteClientExt.class
);
WRAPPED_SYNCHRONOUS_QUEUE_CLASS = setupLogstashClass(
ABSTRACT_WRAPPED_QUEUE_CLASS, JrubyWrappedSynchronousQueueExt::new,
JrubyWrappedSynchronousQueueExt.class
);
WRAPPED_ACKED_QUEUE_CLASS = setupLogstashClass(
ABSTRACT_WRAPPED_QUEUE_CLASS, JRubyWrappedAckedQueueExt::new,
JRubyWrappedAckedQueueExt.class
);
ACKED_QUEUE_CLASS = setupLogstashClass(JRubyAckedQueueExt::new, JRubyAckedQueueExt.class);
QUEUE_FACTORY_CLASS = setupLogstashClass(QueueFactoryExt::new, QueueFactoryExt.class);
RUBY_EVENT_CLASS = setupLogstashClass(
JrubyEventExtLibrary.RubyEvent::new, JrubyEventExtLibrary.RubyEvent.class
);
ABSTRACT_OUTPUT_DELEGATOR_CLASS = LOGSTASH_MODULE.defineClassUnder(
"AbstractOutputDelegator", RUBY.getObject(),
ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR
);
ABSTRACT_OUTPUT_DELEGATOR_CLASS.defineAnnotatedMethods(AbstractOutputDelegatorExt.class);
RUBY_OUTPUT_DELEGATOR_CLASS = setupLogstashClass(
ABSTRACT_OUTPUT_DELEGATOR_CLASS, OutputDelegatorExt::new, OutputDelegatorExt.class
);
JAVA_OUTPUT_DELEGATOR_CLASS = setupLogstashClass(
ABSTRACT_OUTPUT_DELEGATOR_CLASS, JavaOutputDelegatorExt::new,
JavaOutputDelegatorExt.class
);
ABSTRACT_FILTER_DELEGATOR_CLASS = LOGSTASH_MODULE.defineClassUnder(
"AbstractFilterDelegator", RUBY.getObject(),
ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR
);
ABSTRACT_FILTER_DELEGATOR_CLASS.defineAnnotatedMethods(AbstractFilterDelegatorExt.class);
JAVA_FILTER_DELEGATOR_CLASS = setupLogstashClass(
ABSTRACT_FILTER_DELEGATOR_CLASS, JavaFilterDelegatorExt::new,
JavaFilterDelegatorExt.class
);
FILTER_DELEGATOR_CLASS = setupLogstashClass(
ABSTRACT_FILTER_DELEGATOR_CLASS, FilterDelegatorExt::new,
FilterDelegatorExt.class
);
JAVA_INPUT_DELEGATOR_CLASS = setupLogstashClass(JavaInputDelegatorExt::new, JavaInputDelegatorExt.class);
final RubyModule loggingModule = LOGSTASH_MODULE.defineOrGetModuleUnder("Logging");
LOGGER = loggingModule.defineClassUnder("Logger", RUBY.getObject(), LoggerExt::new);
LOGGER.defineAnnotatedMethods(LoggerExt.class);
SLOW_LOGGER = loggingModule.defineClassUnder(
"SlowLogger", RUBY.getObject(), SlowLoggerExt::new);
SLOW_LOGGER.defineAnnotatedMethods(SlowLoggerExt.class);
DEPRECATION_LOGGER = loggingModule.defineClassUnder(
"DeprecationLogger", RUBY.getObject(), DeprecationLoggerExt::new);
DEPRECATION_LOGGER.defineAnnotatedMethods(DeprecationLoggerExt.class);
LOGGABLE_MODULE = UTIL_MODULE.defineModuleUnder("Loggable");
LOGGABLE_MODULE.defineAnnotatedMethods(LoggableExt.class);
ABSTRACT_PIPELINE_CLASS =
setupLogstashClass(AbstractPipelineExt::new, AbstractPipelineExt.class);
final RubyModule json = LOGSTASH_MODULE.defineOrGetModuleUnder("Json");
final RubyClass stdErr = RUBY.getStandardError();
LOGSTASH_ERROR = LOGSTASH_MODULE.defineClassUnder(
"Error", stdErr, JRubyLogstashErrorsExt.LogstashRubyError::new
);
LOGSTASH_MODULE.defineClassUnder(
"EnvironmentError", stdErr, JRubyLogstashErrorsExt.LogstashEnvironmentError::new
);
CONFIGURATION_ERROR_CLASS = LOGSTASH_MODULE.defineClassUnder(
"ConfigurationError", stdErr, JRubyLogstashErrorsExt.ConfigurationError::new
);
LOGSTASH_MODULE.defineClassUnder(
"PluginLoadingError", stdErr, JRubyLogstashErrorsExt.PluginLoadingError::new
);
LOGSTASH_MODULE.defineClassUnder(
"ShutdownSignal", stdErr, JRubyLogstashErrorsExt.ShutdownSignal::new
);
LOGSTASH_MODULE.defineClassUnder(
"PluginNoVersionError", stdErr, JRubyLogstashErrorsExt.PluginNoVersionError::new
);
LOGSTASH_MODULE.defineClassUnder(
"BootstrapCheckError", stdErr, JRubyLogstashErrorsExt.BootstrapCheckError::new
);
BUG_CLASS = LOGSTASH_MODULE.defineClassUnder(
"Bug", stdErr, JRubyLogstashErrorsExt.Bug::new
);
LOGSTASH_MODULE.defineClassUnder(
"ThisMethodWasRemoved", BUG_CLASS,
JRubyLogstashErrorsExt.ThisMethodWasRemoved::new
);
LOGSTASH_MODULE.defineClassUnder(
"ConfigLoadingError", stdErr, JRubyLogstashErrorsExt.ConfigLoadingError::new
);
LOGSTASH_MODULE.defineClassUnder(
"InvalidSourceLoaderSettingError", stdErr,
JRubyLogstashErrorsExt.InvalidSourceLoaderSettingError::new
);
PARSER_ERROR = json.defineClassUnder(
"ParserError", LOGSTASH_ERROR, JRubyLogstashErrorsExt.LogstashRubyParserError::new
);
TIMESTAMP_PARSER_ERROR = LOGSTASH_MODULE.defineClassUnder(
"TimestampParserError", stdErr, JRubyLogstashErrorsExt.LogstashTimestampParserError::new
);
GENERATOR_ERROR = json.defineClassUnder("GeneratorError", LOGSTASH_ERROR,
JRubyLogstashErrorsExt.LogstashRubyGeneratorError::new
);
RUBY_EVENT_CLASS.setConstant("METADATA", RUBY.newString(Event.METADATA));
RUBY_EVENT_CLASS.setConstant(
"METADATA_BRACKETS", RUBY.newString(Event.METADATA_BRACKETS)
);
RUBY_EVENT_CLASS.setConstant("TIMESTAMP", RUBY.newString(Event.TIMESTAMP));
RUBY_EVENT_CLASS.setConstant(
"TIMESTAMP_FAILURE_TAG", RUBY.newString(Event.TIMESTAMP_FAILURE_TAG)
);
RUBY_EVENT_CLASS.setConstant(
"TIMESTAMP_FAILURE_FIELD", RUBY.newString(Event.TIMESTAMP_FAILURE_FIELD)
);
RUBY_EVENT_CLASS.setConstant("VERSION", RUBY.newString(Event.VERSION));
RUBY_EVENT_CLASS.setConstant("VERSION_ONE", RUBY.newString(Event.VERSION_ONE));
RUBY_EVENT_CLASS.defineAnnotatedMethods(JrubyEventExtLibrary.RubyEvent.class);
RUBY_EVENT_CLASS.defineAnnotatedConstants(JrubyEventExtLibrary.RubyEvent.class);
PLUGIN_FACTORY_CLASS = PLUGINS_MODULE.defineClassUnder(
"PluginFactory", RUBY.getObject(), PluginFactoryExt::new
);
PLUGIN_FACTORY_CLASS.defineAnnotatedMethods(PluginFactoryExt.class);
PLUGIN_CONTEXTUALIZER_MODULE = PLUGINS_MODULE.defineOrGetModuleUnder("Contextualizer");
PLUGIN_CONTEXTUALIZER_MODULE.defineAnnotatedMethods(ContextualizerExt.class);
UNIVERSAL_PLUGIN_CLASS =
setupLogstashClass(UniversalPluginExt::new, UniversalPluginExt.class);
EVENT_DISPATCHER_CLASS =
setupLogstashClass(EventDispatcherExt::new, EventDispatcherExt.class);
PIPELINE_REPORTER_CLASS =
setupLogstashClass(PipelineReporterExt::new, PipelineReporterExt.class);
PIPELINE_REPORTER_CLASS.defineAnnotatedMethods(PipelineReporterExt.class);
PIPELINE_REPORTER_SNAPSHOT_CLASS = PIPELINE_REPORTER_CLASS.defineClassUnder(
"Snapshot", RUBY.getObject(), PipelineReporterExt.SnapshotExt::new
);
PIPELINE_REPORTER_SNAPSHOT_CLASS.defineAnnotatedMethods(
PipelineReporterExt.SnapshotExt.class
);
CONVERGE_RESULT_CLASS = setupLogstashClass(ConvergeResultExt::new, ConvergeResultExt.class);
ACTION_RESULT_CLASS = CONVERGE_RESULT_CLASS.defineClassUnder(
"ActionResult", RUBY.getObject(), ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR
);
ACTION_RESULT_CLASS.defineAnnotatedMethods(ConvergeResultExt.ActionResultExt.class);
SUCCESSFUL_ACTION_CLASS = CONVERGE_RESULT_CLASS.defineClassUnder(
"SuccessfulAction", ACTION_RESULT_CLASS, ConvergeResultExt.SuccessfulActionExt::new
);
SUCCESSFUL_ACTION_CLASS.defineAnnotatedMethods(ConvergeResultExt.SuccessfulActionExt.class);
FAILED_ACTION_CLASS = CONVERGE_RESULT_CLASS.defineClassUnder(
"FailedAction", ACTION_RESULT_CLASS, ConvergeResultExt.FailedActionExt::new
);
FAILED_ACTION_CLASS.defineAnnotatedMethods(ConvergeResultExt.FailedActionExt.class);
HOOKS_REGISTRY_CLASS =
PLUGINS_MODULE.defineClassUnder("HooksRegistry", RUBY.getObject(), HooksRegistryExt::new);
HOOKS_REGISTRY_CLASS.defineAnnotatedMethods(HooksRegistryExt.class);
RUBY.getGlobalVariables().set("$LS_JARS_LOADED", RUBY.newString("true"));
RubyJavaIntegration.setupRubyJavaIntegration(RUBY);
}