supports collecting metrics and logs

Author: CodePrometheus

docs/en/setup/MeterReporter.md

@@ -0,0 +1,58 @@
+# Ruby Agent Meter Reporter
+
+The meter reporter feature enables collection and reporting of runtime metrics to the SkyWalking OAP backend.
+
+## Features
+
+### Runtime Metrics (Enabled by Default)
+
+The agent automatically collects Ruby runtime metrics when `meter_reporter_active` and `runtime_meter_reporter_active` are enabled (default: true).
+
+#### Collected Metrics
+
+**CPU Metrics:**
+- `instance_ruby_total_cpu_utilization` - System total CPU usage percentage
+- `instance_ruby_process_cpu_utilization` - Ruby process CPU usage percentage
+
+**Memory Metrics:**
+- `instance_ruby_total_mem_utilization` - System total memory usage percentage
+- `instance_ruby_process_mem_utilization` - Ruby process memory usage percentage
+
+**Garbage Collection Metrics:**
+- `instance_ruby_gc_count` - Total GC execution count
+- `instance_ruby_gc_time` - GC execution time (milliseconds)
+- `instance_ruby_gc_minor_count` - Minor GC count (if available)
+- `instance_ruby_gc_major_count` - Major GC count (if available)
+- `instance_ruby_heap_live_slots` - Number of live heap slots
+- `instance_ruby_heap_free_slots` - Number of free heap slots
+
+**Thread Metrics:**
+- `instance_ruby_thread_active_count` - Number of active threads
+- `instance_ruby_thread_count` - Total thread count
+- `instance_ruby_fiber_count` - Total fiber count
+
+## Configuration
+
+### Enable/Disable Meter Reporter
+
+```ruby
+# Enable meter reporter (default: true)
+config[:meter_reporter_active] = true
+
+# Enable runtime metrics (default: true)
+config[:runtime_meter_reporter_active] = true
+
+# Or via environment variables
+ENV['SW_AGENT_METER_REPORTER_ACTIVE'] = 'true'
+ENV['SW_AGENT_RUNTIME_METER_REPORTER_ACTIVE'] = 'true'
+```
+
+### Configure Report Period
+
+```ruby
+# Set meter report period in seconds (default: 20)
+config[:meter_report_period] = 20
+
+# Set maximum meter queue size (default: 1000)
+config[:max_meter_queue_size] = 1000
+```

lib/skywalking/agent.rb

@@ -17,6 +17,7 @@
 require_relative 'environment'
 require_relative 'plugins_manager'
 require_relative 'reporter/report'
+require_relative 'reporter/log_buffer_trigger'
 require_relative 'tracing/span_context'
 require_relative 'tracing/carrier_item'
 require_relative 'tracing/segment'
@@ -62,13 +63,21 @@ def started?
       end
 
       attr_reader :logger, :agent_config
+      
+      # Get the singleton instance
+      # @return [Agent, nil] the agent instance or nil if not started
+      def instance
+        @agent
+      end
     end
 
-    attr_reader :plugins, :reporter
+    attr_reader :plugins, :reporter, :log_buffer, :config
 
     def initialize(config)
+      @config = config
       @plugins = Plugins::PluginsManager.new(config)
       @reporter = Reporter::Report.new(config)
+      @log_buffer = Reporter::LogBufferTrigger.new(config)
 
       add_shutdown_hook
     end
@@ -80,6 +89,9 @@ def environment
     def start!
       @plugins.init_plugins
       @reporter.init_reporter
+      # Start log reporting thread
+      start_log_reporting_thread if @config[:log_reporter_active]
+
       self
     end
 
@@ -94,5 +106,44 @@ def add_shutdown_hook
         shutdown
       end
     end
+
+    # Check if log reporter is active
+    # @return [Boolean] true if log reporter is active
+    def log_reporter_active?
+      @config[:log_reporter_active]
+    end
+
+    private
+
+    # Start the log reporting thread
+    def start_log_reporting_thread
+      Thread.new do
+        loop do
+          break unless log_reporter_active?
+          
+          process_log_queue
+          sleep @config[:log_report_period]
+        end
+      end
+    end
+
+    # Process the log queue and send data to the server
+    def process_log_queue
+      log_count = 0
+      Enumerator.new do |yielder|
+        while (log_data = log_buffer.stream_data)
+          log_data.each do |data| 
+            log_count += 1
+            yielder << data 
+          end
+        end
+      end.each_slice(10) do |batch|
+        begin
+          reporter.report_log(batch)
+        rescue => e
+          Agent.logger.warn "Failed to report log data: #{e.message}"
+        end
+      end
+    end
   end
 end

lib/skywalking/configuration.rb

@@ -100,6 +100,46 @@ class Configuration
         default: 10000,
         desc: 'The maximum queue size for reporting data'
       },
+      :meter_reporter_active => {
+        type: :bool,
+        default: true,
+        desc: 'Enable meter reporter'
+      },
+      :runtime_meter_reporter_active => {
+        type: :bool,
+        default: true,
+        desc: 'Enable Ruby runtime meter reporter'
+      },
+      :meter_report_period => {
+        type: :int,
+        default: 20,
+        desc: 'Meter report period in seconds'
+      },
+      :max_meter_queue_size => {
+        type: :int,
+        default: 1000,
+        desc: 'Maximum meter queue size'
+      },
+      :log_reporter_active => {
+        type: :bool,
+        default: true,
+        desc: 'Enable log reporter'
+      },
+      :log_reporter_level => {
+        type: :int,
+        default: Logger::INFO,
+        desc: 'Minimum log level to report (Logger::DEBUG, Logger::INFO, Logger::WARN, Logger::ERROR, Logger::FATAL)'
+      },
+      :log_report_period => {
+        type: :int,
+        default: 5,
+        desc: 'Log report period in seconds'
+      },
+      :max_log_queue_size => {
+        type: :int,
+        default: 1000,
+        desc: 'Maximum log queue size'
+      }
     }.freeze
 
     # @api private
@@ -181,7 +221,7 @@ def override_config_by_env
           new_config[env_key] = !%w[0 false].include?(env_value.strip.downcase)
           # rubocop:enable Performance/CollectionLiteralInLoop
         when :int
-          new_config[env_key] = env_value.to_s
+          new_config[env_key] = env_value.to_i
         else
           env_value
         end

lib/skywalking/meter.rb

@@ -0,0 +1,38 @@
+#  Licensed to the Apache Software Foundation (ASF) under one or more
+#  contributor license agreements.  See the NOTICE file distributed with
+#  this work for additional information regarding copyright ownership.
+#  The ASF licenses this file to You under the Apache License, Version 2.0
+#  (the "License"); you may not use this file except in compliance with
+#  the License.  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+require_relative 'meter/base'
+require_relative 'meter/meter_service'
+require_relative 'meter/runtime/cpu_data_source'
+require_relative 'meter/runtime/mem_data_source'
+require_relative 'meter/runtime/gc_data_source'
+require_relative 'meter/runtime/thread_data_source'
+
+module Skywalking
+  # Main module for meter functionality
+  module Meter
+    # Export key classes for external use
+    DataSource = DataSource
+    Gauge = Gauge
+    MeterService = MeterService
+    
+    module Runtime
+      CpuDataSource = CpuDataSource
+      MemDataSource = MemDataSource
+      GcDataSource = GcDataSource
+      ThreadDataSource = ThreadDataSource
+    end
+  end
+end

lib/skywalking/meter/base.rb

@@ -0,0 +1,79 @@
+#  Licensed to the Apache Software Foundation (ASF) under one or more
+#  contributor license agreements.  See the NOTICE file distributed with
+#  this work for additional information regarding copyright ownership.
+#  The ASF licenses this file to You under the Apache License, Version 2.0
+#  (the "License"); you may not use this file except in compliance with
+#  the License.  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+require_relative '../reporter/client/proto'
+
+module Skywalking
+  module Meter
+    # Base class for all data sources
+    class DataSource
+      # Automatically register all generator methods as gauges
+      # @param meter_service [MeterService] the service to register gauges with
+      def register(meter_service)
+        methods.grep(/_generator$/).each do |method_name|
+          metric_name = "instance_ruby_#{method_name.to_s.sub('_generator', '')}"
+          # Create a lambda that calls the generator method
+          getter = lambda { send(method_name) }
+          gauge = Gauge.new(metric_name, getter)
+          meter_service.register(gauge)
+        end
+      end
+    end
+
+    # Represents a gauge metric that reports instantaneous values
+    class Gauge
+      attr_reader :name
+
+      # @param name [String] metric name
+      # @param getter [Proc] a callable that returns the current value
+      def initialize(name, getter)
+        @name = name
+        @getter = getter
+        @labels = []
+      end
+
+      # Add a label to this gauge
+      # @param key [String] label key
+      # @param value [String] label value
+      # @return [self]
+      def add_label(key, value)
+        @labels << Label.new(name: key, value: value)
+        self
+      end
+
+      # Collect current metric value
+      # @return [MeterData] meter data
+      def collect
+        value = @getter.call
+        MeterData.new(
+          singleValue: MeterSingleValue.new(
+            name: @name,
+            value: value.to_f,
+            labels: @labels
+          )
+        )
+      rescue
+        # Return zero value if getter fails
+        MeterData.new(
+          singleValue: MeterSingleValue.new(
+            name: @name,
+            value: 0.0,
+            labels: @labels
+          )
+        )
+      end
+    end
+  end
+end