rails_error_dashboard 0.3.1 → 0.4.1

data/lib/rails_error_dashboard/commands/log_error.rb

@@ -37,6 +37,34 @@ module RailsErrorDashboard
           context = context.merge(_serialized_system_health: Services::SystemHealthSnapshot.capture)
         end
 
+        # Capture local variables NOW (TracePoint attaches to exception, must extract before job dispatch)
+        if RailsErrorDashboard.configuration.enable_local_variables
+          begin
+            raw_locals = Services::LocalVariableCapturer.extract(exception)
+            if raw_locals.is_a?(Hash) && raw_locals.any?
+              context = context.merge(_serialized_local_variables: Services::VariableSerializer.call(raw_locals))
+            end
+          rescue => e
+            RailsErrorDashboard::Logger.debug("[RailsErrorDashboard] Async local variable serialization failed: #{e.message}")
+          end
+        end
+
+        # Capture instance variables NOW (same reason — attached to exception object)
+        if RailsErrorDashboard.configuration.enable_instance_variables
+          begin
+            raw_ivars = Services::LocalVariableCapturer.extract_instance_vars(exception)
+            if raw_ivars.is_a?(Hash) && raw_ivars.any?
+              context = context.merge(_serialized_instance_variables: Services::VariableSerializer.call(
+                raw_ivars,
+                max_count: RailsErrorDashboard.configuration.instance_variable_max_count,
+                additional_filter_patterns: RailsErrorDashboard.configuration.instance_variable_filter_patterns
+              ))
+            end
+          rescue => e
+            RailsErrorDashboard::Logger.debug("[RailsErrorDashboard] Async instance variable serialization failed: #{e.message}")
+          end
+        end
+
         # Enqueue the async job using ActiveJob
         # The queue adapter (:sidekiq, :solid_queue, :async) is configured separately
         AsyncErrorLoggingJob.perform_later(exception_data, context)
@@ -179,6 +207,46 @@ module RailsErrorDashboard
           attributes[:system_health] = health_data.to_json
         end
 
+        # Capture local variables (if enabled and column exists)
+        if ErrorLog.column_names.include?("local_variables") && RailsErrorDashboard.configuration.enable_local_variables
+          begin
+            # Sync path: extract from exception ivar
+            raw_locals = Services::LocalVariableCapturer.extract(@exception)
+            # Async path fallback: use pre-serialized locals from call_async context
+            raw_locals ||= @context[:_serialized_local_variables]
+            if raw_locals.is_a?(Hash) && raw_locals.any?
+              serialized = raw_locals == @context[:_serialized_local_variables] ? raw_locals : Services::VariableSerializer.call(raw_locals)
+              attributes[:local_variables] = serialized.to_json
+            end
+          rescue => e
+            RailsErrorDashboard::Logger.debug("[RailsErrorDashboard] Local variable serialization failed: #{e.message}")
+          end
+        end
+
+        # Capture instance variables (if enabled and column exists)
+        if ErrorLog.column_names.include?("instance_variables") && RailsErrorDashboard.configuration.enable_instance_variables
+          begin
+            # Sync path: extract from exception ivar
+            raw_ivars = Services::LocalVariableCapturer.extract_instance_vars(@exception)
+            # Async path fallback: use pre-serialized ivars from call_async context
+            raw_ivars ||= @context[:_serialized_instance_variables]
+            if raw_ivars.is_a?(Hash) && raw_ivars.any?
+              serialized = if raw_ivars == @context[:_serialized_instance_variables]
+                raw_ivars
+              else
+                Services::VariableSerializer.call(
+                  raw_ivars,
+                  max_count: RailsErrorDashboard.configuration.instance_variable_max_count,
+                  additional_filter_patterns: RailsErrorDashboard.configuration.instance_variable_filter_patterns
+                )
+              end
+              attributes[:instance_variables] = serialized.to_json
+            end
+          rescue => e
+            RailsErrorDashboard::Logger.debug("[RailsErrorDashboard] Instance variable serialization failed: #{e.message}")
+          end
+        end
+
         # Find existing error or create new one
         # This ensures accurate occurrence tracking
         error_log = ErrorLog.find_or_increment_by_hash(error_hash, attributes.merge(error_hash: error_hash))

data/lib/rails_error_dashboard/configuration.rb

@@ -127,6 +127,37 @@ module RailsErrorDashboard
     # System health snapshot (GC, memory, threads, connection pool at error time)
     attr_accessor :enable_system_health            # Master switch (default: false)
 
+    # Local variable capture via TracePoint(:raise)
+    attr_accessor :enable_local_variables            # Master switch (default: false)
+    attr_accessor :local_variable_max_count           # Max variables to capture (default: 15)
+    attr_accessor :local_variable_max_depth           # Max object nesting depth (default: 3)
+    attr_accessor :local_variable_max_string_length   # Max string value length (default: 200)
+    attr_accessor :local_variable_max_array_items     # Max array items to serialize (default: 10)
+    attr_accessor :local_variable_max_hash_items      # Max hash entries to serialize (default: 20)
+    attr_accessor :local_variable_filter_patterns     # Additional sensitive name patterns (default: [])
+
+    # Instance variable capture from tp.self (receiver object at raise time)
+    attr_accessor :enable_instance_variables           # Master switch (default: false)
+    attr_accessor :instance_variable_max_count          # Max ivars to capture (default: 20)
+    attr_accessor :instance_variable_filter_patterns    # Additional sensitive ivar patterns (default: [])
+
+    # Swallowed exception detection via TracePoint(:raise) + TracePoint(:rescue) (Ruby 3.3+ only)
+    attr_accessor :detect_swallowed_exceptions          # Master switch (default: false)
+    attr_accessor :swallowed_exception_max_cache_size   # Max entries per thread (default: 1000)
+    attr_accessor :swallowed_exception_flush_interval   # Seconds between flushes (default: 60)
+    attr_accessor :swallowed_exception_threshold        # Rescue ratio to flag (default: 0.95)
+    attr_accessor :swallowed_exception_ignore_classes   # Additional exception classes to skip (default: [])
+
+    # Process crash capture via at_exit hook
+    attr_accessor :enable_crash_capture                 # Master switch (default: false)
+    attr_accessor :crash_capture_path                   # Directory for crash files (default: Dir.tmpdir)
+
+    # On-demand diagnostic dump (rake task + dashboard endpoint)
+    attr_accessor :enable_diagnostic_dump               # Master switch (default: false)
+
+    # Rack Attack event tracking (requires enable_breadcrumbs = true)
+    attr_accessor :enable_rack_attack_tracking          # Master switch (default: false)
+
     # Notification callbacks (managed via helper methods, not set directly)
     attr_reader :notification_callbacks
 
@@ -238,6 +269,37 @@ module RailsErrorDashboard
       # System health snapshot defaults - OFF by default (opt-in)
       @enable_system_health = false  # Capture GC, memory, threads, connection pool at error time
 
+      # Local variable capture defaults - OFF by default (opt-in)
+      @enable_local_variables = false           # TracePoint(:raise) for local var capture
+      @local_variable_max_count = 15            # Max variables per exception
+      @local_variable_max_depth = 3             # Max nesting depth for objects
+      @local_variable_max_string_length = 200   # Truncate strings beyond this
+      @local_variable_max_array_items = 10      # Max array items to serialize
+      @local_variable_max_hash_items = 20       # Max hash entries to serialize
+      @local_variable_filter_patterns = []      # Additional sensitive variable name patterns
+
+      # Instance variable capture defaults - OFF by default (opt-in)
+      @enable_instance_variables = false         # Capture ivars from tp.self at raise time
+      @instance_variable_max_count = 20          # Max ivars per exception
+      @instance_variable_filter_patterns = []    # Additional sensitive ivar name patterns
+
+      # Swallowed exception detection defaults - OFF by default (Ruby 3.3+ opt-in)
+      @detect_swallowed_exceptions = false       # TracePoint(:raise) + TracePoint(:rescue)
+      @swallowed_exception_max_cache_size = 1000 # Max entries per thread-local hash
+      @swallowed_exception_flush_interval = 60   # Seconds between DB flushes
+      @swallowed_exception_threshold = 0.95      # Rescue ratio to flag as swallowed
+      @swallowed_exception_ignore_classes = []   # Additional exception classes to skip
+
+      # Process crash capture defaults - OFF by default (opt-in)
+      @enable_crash_capture = false     # at_exit hook for fatal crash capture
+      @crash_capture_path = nil         # nil = Dir.tmpdir
+
+      # Diagnostic dump defaults - OFF by default (opt-in)
+      @enable_diagnostic_dump = false   # On-demand system state snapshot
+
+      # Rack Attack event tracking defaults - OFF by default (opt-in, requires breadcrumbs)
+      @enable_rack_attack_tracking = false
+
       # Internal logging defaults - SILENT by default
       @enable_internal_logging = false  # Opt-in for debugging
       @log_level = :silent  # Silent by default, use :debug, :info, :warn, :error, or :silent
@@ -256,11 +318,13 @@ module RailsErrorDashboard
 
     # Validate configuration values
     # Raises ConfigurationError if any validation fails
+    # Logs warnings for non-fatal issues (e.g., Ruby version incompatibilities)
     #
     # @raise [ConfigurationError] if configuration is invalid
     # @return [true] if configuration is valid
     def validate!
       errors = []
+      warnings = []
 
       # Validate sampling_rate (must be between 0.0 and 1.0)
       if sampling_rate && (sampling_rate < 0.0 || sampling_rate > 1.0)
@@ -330,6 +394,59 @@ module RailsErrorDashboard
         errors << "n_plus_one_threshold must be at least 2 (got: #{n_plus_one_threshold})"
       end
 
+      # Validate local variable capture settings
+      if enable_local_variables
+        if local_variable_max_count && local_variable_max_count < 1
+          errors << "local_variable_max_count must be at least 1 (got: #{local_variable_max_count})"
+        end
+        if local_variable_max_depth && local_variable_max_depth < 1
+          errors << "local_variable_max_depth must be at least 1 (got: #{local_variable_max_depth})"
+        end
+        if local_variable_max_string_length && local_variable_max_string_length < 1
+          errors << "local_variable_max_string_length must be at least 1 (got: #{local_variable_max_string_length})"
+        end
+      end
+
+      # Validate instance variable capture settings
+      if enable_instance_variables && instance_variable_max_count && instance_variable_max_count < 1
+        errors << "instance_variable_max_count must be at least 1 (got: #{instance_variable_max_count})"
+      end
+
+      # Validate swallowed exception detection settings
+      # Auto-disable on Ruby < 3.3 (warn, don't crash)
+      if detect_swallowed_exceptions && RUBY_VERSION < "3.3"
+        warnings << "detect_swallowed_exceptions requires Ruby 3.3+ (current: #{RUBY_VERSION}). " \
+                    "TracePoint(:rescue) was added in Ruby 3.3 (Feature #19572). " \
+                    "Feature has been auto-disabled. Upgrade Ruby to use this feature."
+        @detect_swallowed_exceptions = false
+      end
+      # Validate sub-settings only if feature is still active after version check
+      if detect_swallowed_exceptions
+        if swallowed_exception_max_cache_size && swallowed_exception_max_cache_size < 1
+          errors << "swallowed_exception_max_cache_size must be at least 1 (got: #{swallowed_exception_max_cache_size})"
+        end
+        if swallowed_exception_flush_interval && swallowed_exception_flush_interval < 1
+          errors << "swallowed_exception_flush_interval must be at least 1 (got: #{swallowed_exception_flush_interval})"
+        end
+        if swallowed_exception_threshold && (swallowed_exception_threshold < 0.0 || swallowed_exception_threshold > 1.0)
+          errors << "swallowed_exception_threshold must be between 0.0 and 1.0 (got: #{swallowed_exception_threshold})"
+        end
+      end
+
+      # Validate rack_attack tracking requires breadcrumbs
+      if enable_rack_attack_tracking && !enable_breadcrumbs
+        warnings << "enable_rack_attack_tracking requires enable_breadcrumbs = true. " \
+                    "Rack Attack tracking has been auto-disabled."
+        @enable_rack_attack_tracking = false
+      end
+
+      # Validate crash capture path (must exist if custom path specified)
+      if enable_crash_capture && crash_capture_path
+        unless Dir.exist?(crash_capture_path)
+          errors << "crash_capture_path '#{crash_capture_path}' does not exist"
+        end
+      end
+
       # Validate notification dependencies
       if enable_slack_notifications && (slack_webhook_url.nil? || slack_webhook_url.strip.empty?)
         errors << "slack_webhook_url is required when enable_slack_notifications is true"
@@ -388,6 +505,11 @@ module RailsErrorDashboard
         errors << "notification_threshold_alerts must be an Array (got: #{notification_threshold_alerts.class})"
       end
 
+      # Log warnings (non-fatal issues)
+      warnings.each do |warning|
+        Rails.logger.warn "[Rails Error Dashboard] #{warning}" if defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
+      end
+
       # Raise exception if any errors found
       raise ConfigurationError, errors if errors.any?
 

data/lib/rails_error_dashboard/engine.rb

@@ -69,6 +69,30 @@ module RailsErrorDashboard
       if RailsErrorDashboard.configuration.enable_breadcrumbs
         RailsErrorDashboard::Subscribers::BreadcrumbSubscriber.subscribe!
       end
+
+      # Subscribe to Rack Attack AS::Notifications events (requires breadcrumbs + Rack::Attack)
+      if RailsErrorDashboard.configuration.enable_rack_attack_tracking &&
+         RailsErrorDashboard.configuration.enable_breadcrumbs &&
+         defined?(Rack::Attack)
+        RailsErrorDashboard::Subscribers::RackAttackSubscriber.subscribe!
+      end
+
+      # Enable TracePoint(:raise) for local variable and/or instance variable capture
+      if RailsErrorDashboard.configuration.enable_local_variables ||
+         RailsErrorDashboard.configuration.enable_instance_variables
+        RailsErrorDashboard::Services::LocalVariableCapturer.enable!
+      end
+
+      # Enable TracePoint(:raise) + TracePoint(:rescue) for swallowed exception detection
+      if RailsErrorDashboard.configuration.detect_swallowed_exceptions
+        RailsErrorDashboard::Services::SwallowedExceptionTracker.enable!
+      end
+
+      # Import crash files from previous process death, then register at_exit hook
+      if RailsErrorDashboard.configuration.enable_crash_capture
+        RailsErrorDashboard::Services::CrashCapture.import!
+        RailsErrorDashboard::Services::CrashCapture.enable!
+      end
     end
   end
 end

data/lib/rails_error_dashboard/queries/dashboard_stats.rb

@@ -309,37 +309,58 @@ module RailsErrorDashboard
       def top_errors_by_impact
         base_scope.where("occurred_at >= ?", 7.days.ago)
                 .group(:error_type, :id)
-                .select("error_type, id, occurrence_count,
+                .select("error_type, id, message, occurred_at, occurrence_count,
                         COUNT(DISTINCT user_id) as affected_users,
                         COUNT(DISTINCT user_id) * occurrence_count as impact_score")
                 .order("impact_score DESC")
                 .limit(6)
                 .map do |error|
-                  full_error = ErrorLog.find(error.id)
                   {
                     id: error.id,
                     error_type: error.error_type,
-                    message: full_error.message&.truncate(80),
-                    severity: full_error.severity,
+                    message: error.message&.truncate(80),
+                    severity: Services::SeverityClassifier.classify(error.error_type),
                     occurrence_count: error.occurrence_count,
                     affected_users: error.affected_users.to_i,
                     impact_score: error.impact_score.to_i,
-                    occurred_at: full_error.occurred_at
+                    occurred_at: error.occurred_at
                   }
                 end
       end
 
       # Calculate average resolution time (MTTR) in hours for the last 30 days
+      # Uses SQL AVG to avoid loading all resolved errors into Ruby memory
       def average_resolution_time
-        resolved_errors = base_scope.resolved.where("resolved_at >= ?", 30.days.ago)
-        return nil if resolved_errors.empty?
+        scope = base_scope.resolved.where("resolved_at >= ?", 30.days.ago)
+        return nil unless scope.exists?
 
-        total_seconds = resolved_errors.sum do |error|
-          (error.resolved_at - error.occurred_at).to_i
+        avg_seconds = scope.pick(Arel.sql(avg_seconds_sql))
+        return nil unless avg_seconds
+
+        (avg_seconds.to_f / 3600.0).round(2)
+      end
+
+      def avg_seconds_sql
+        case db_adapter
+        when :postgresql
+          "AVG(EXTRACT(EPOCH FROM (resolved_at - occurred_at)))"
+        when :mysql
+          "AVG(TIMESTAMPDIFF(SECOND, occurred_at, resolved_at))"
+        else
+          # SQLite: julianday difference * 86400 gives seconds
+          "AVG((julianday(resolved_at) - julianday(occurred_at)) * 86400)"
         end
+      end
 
-        average_seconds = total_seconds / resolved_errors.count.to_f
-        (average_seconds / 3600.0).round(2) # Convert to hours
+      def db_adapter
+        adapter = ErrorLog.connection.adapter_name.downcase
+        if adapter.include?("postgresql")
+          :postgresql
+        elsif adapter.include?("mysql") || adapter.include?("trilogy")
+          :mysql
+        else
+          :sqlite
+        end
       end
     end
   end

data/lib/rails_error_dashboard/queries/rack_attack_summary.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Queries
+    # Query: Aggregate Rack Attack events from breadcrumbs across all errors
+    # Scans error_logs breadcrumbs JSON, filters for "rack_attack" category crumbs,
+    # and groups by rule name with counts, unique IPs, paths, and error associations.
+    class RackAttackSummary
+      def self.call(days = 30, application_id: nil)
+        new(days, application_id: application_id).call
+      end
+
+      def initialize(days = 30, application_id: nil)
+        @days = days
+        @application_id = application_id
+        @start_date = days.days.ago
+      end
+
+      def call
+        {
+          events: aggregated_events
+        }
+      end
+
+      private
+
+      def base_query
+        scope = ErrorLog.where("occurred_at >= ?", @start_date)
+                        .where.not(breadcrumbs: nil)
+        scope = scope.where(application_id: @application_id) if @application_id.present?
+        scope
+      end
+
+      def aggregated_events
+        results = {}
+
+        base_query.select(:id, :breadcrumbs, :occurred_at).find_each(batch_size: 500) do |error_log|
+          crumbs = parse_breadcrumbs(error_log.breadcrumbs)
+          next if crumbs.empty?
+
+          rack_attack_crumbs = crumbs.select { |c| c["c"] == "rack_attack" }
+          next if rack_attack_crumbs.empty?
+
+          rack_attack_crumbs.each do |crumb|
+            meta = crumb["meta"] || {}
+            rule = meta["rule"].to_s.presence || "unknown"
+
+            if results[rule]
+              results[rule][:count] += 1
+              results[rule][:ips] << meta["discriminator"].to_s if meta["discriminator"].present?
+              results[rule][:paths] << meta["path"].to_s if meta["path"].present?
+              results[rule][:error_ids] << error_log.id
+              results[rule][:last_seen] = [ results[rule][:last_seen], error_log.occurred_at ].compact.max
+            else
+              results[rule] = {
+                rule: rule,
+                match_type: meta["type"].to_s,
+                count: 1,
+                ips: Set.new([ meta["discriminator"].to_s ].reject(&:blank?)),
+                paths: Set.new([ meta["path"].to_s ].reject(&:blank?)),
+                error_ids: [ error_log.id ],
+                last_seen: error_log.occurred_at
+              }
+            end
+          end
+        end
+
+        results.values.each do |r|
+          r[:error_ids] = r[:error_ids].uniq
+          r[:error_count] = r[:error_ids].size
+          r[:unique_ips] = r[:ips].size
+          r[:top_path] = r[:paths].first
+          r[:ips] = r[:ips].to_a
+          r[:paths] = r[:paths].to_a
+        end
+        results.values.sort_by { |r| -r[:count] }
+      rescue => e
+        Rails.logger.error("[RailsErrorDashboard] RackAttackSummary query failed: #{e.class}: #{e.message}")
+        []
+      end
+
+      def parse_breadcrumbs(raw)
+        return [] if raw.blank?
+        JSON.parse(raw)
+      rescue JSON::ParserError
+        []
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/queries/swallowed_exception_summary.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Queries
+    # Query: Aggregate swallowed exception data across hourly buckets for dashboard display.
+    #
+    # Groups by (exception_class, raise_location) and sums raise/rescue counts across
+    # all rescue_locations and time buckets. This is important because the tracker stores
+    # raise events (rescue_location=nil) and rescue events (rescue_location set) in separate
+    # rows — grouping by rescue_location too would prevent the ratio from ever being computed.
+    # Filters to entries with rescue_ratio >= threshold (i.e., likely swallowed).
+    # Returns array of hashes sorted by total rescue count descending.
+    class SwallowedExceptionSummary
+      def self.call(days = 30, application_id: nil)
+        new(days, application_id: application_id).call
+      end
+
+      def initialize(days = 30, application_id: nil)
+        @days = days
+        @application_id = application_id
+        @start_date = days.days.ago.beginning_of_hour
+        @threshold = RailsErrorDashboard.configuration.swallowed_exception_threshold
+      end
+
+      def call
+        entries = aggregated_entries
+        {
+          entries: entries,
+          summary: {
+            total_swallowed_classes: entries.map { |e| e[:exception_class] }.uniq.size,
+            total_rescue_count: entries.sum { |e| e[:rescue_count] },
+            total_raise_count: entries.sum { |e| e[:raise_count] }
+          }
+        }
+      rescue => e
+        Rails.logger.error("[RailsErrorDashboard] SwallowedExceptionSummary failed: #{e.class}: #{e.message}")
+        { entries: [], summary: { total_swallowed_classes: 0, total_rescue_count: 0, total_raise_count: 0 } }
+      end
+
+      private
+
+      def base_query
+        return SwallowedException.none unless table_exists?
+
+        scope = SwallowedException.since(@start_date)
+        scope = scope.for_application(@application_id) if @application_id.present?
+        scope
+      end
+
+      def aggregated_entries
+        # Group by (exception_class, raise_location) only — NOT rescue_location.
+        # The tracker stores raise events (rescue_location=nil) and rescue events
+        # (rescue_location set) as separate DB rows. Grouping by rescue_location
+        # would keep them separate, making the ratio always 0 or infinity.
+        rows = base_query
+          .group(:exception_class, :raise_location)
+          .select(
+            :exception_class, :raise_location,
+            "SUM(raise_count) AS total_raise_count",
+            "SUM(rescue_count) AS total_rescue_count",
+            "MAX(last_seen_at) AS last_seen",
+            "MAX(rescue_location) AS top_rescue_location"
+          )
+
+        rows.filter_map do |row|
+          raise_count = row.total_raise_count.to_i
+          rescue_count = row.total_rescue_count.to_i
+          ratio = raise_count > 0 ? (rescue_count.to_f / raise_count).round(4) : 0.0
+
+          next unless ratio >= @threshold
+
+          last_seen = row.last_seen
+          last_seen = Time.zone.parse(last_seen) if last_seen.is_a?(String)
+
+          {
+            exception_class: row.exception_class,
+            raise_location: row.raise_location,
+            rescue_location: row.top_rescue_location,
+            raise_count: raise_count,
+            rescue_count: rescue_count,
+            rescue_ratio: ratio,
+            last_seen: last_seen
+          }
+        end.sort_by { |e| -e[:rescue_count] }
+      rescue => e
+        Rails.logger.error("[RailsErrorDashboard] SwallowedExceptionSummary query failed: #{e.class}: #{e.message}")
+        []
+      end
+
+      def table_exists?
+        SwallowedException.table_exists?
+      rescue ActiveRecord::NoDatabaseError, ActiveRecord::StatementInvalid
+        false
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/services/breadcrumb_collector.rb

@@ -114,6 +114,18 @@ module RailsErrorDashboard
         []
       end
 
+      # Non-destructive read of current breadcrumbs (does NOT clear the buffer)
+      # Used by DiagnosticDumpGenerator for on-demand snapshots.
+      # @return [Array<Hash>] Array of breadcrumb hashes (empty if none)
+      def self.current_breadcrumbs
+        buffer = Thread.current[THREAD_KEY]
+        return [] unless buffer
+        buffer.to_a
+      rescue => e
+        RailsErrorDashboard::Logger.debug("[RailsErrorDashboard] BreadcrumbCollector.current_breadcrumbs failed: #{e.message}")
+        []
+      end
+
       # Get the current buffer (for inspection)
       # @return [RingBuffer, nil]
       def self.current_buffer