dbwatcher 1.1.3 → 1.1.5

data/lib/dbwatcher/services/diagram_strategies/base_diagram_strategy.rb

@@ -8,6 +8,8 @@ module Dbwatcher
       # Defines the common interface and shared behavior for all diagram generation
       # strategies. Subclasses must implement the render_diagram method.
       class BaseDiagramStrategy
+        include Dbwatcher::Logging
+
         attr_reader :syntax_builder, :logger
 
         # Initialize strategy with dependencies
@@ -25,8 +27,8 @@ module Dbwatcher
         # @param dataset [Dataset] standardized dataset
         # @return [Hash] diagram generation result
         def generate_from_dataset(dataset)
-          @logger.info("Generating diagram from dataset with #{dataset.entities.size} entities and " \
-                       "#{dataset.relationships.size} relationships")
+          log_info("Generating diagram from dataset with #{dataset.entities.size} entities and " \
+                   "#{dataset.relationships.size} relationships")
           start_time = Time.current
 
           begin
@@ -40,7 +42,7 @@ module Dbwatcher
 
             result
           rescue StandardError => e
-            @logger.error("Diagram generation failed: #{e.class}: #{e.message}\n#{e.backtrace.join("\n")}")
+            log_error("Diagram generation failed: #{e.class}: #{e.message}\n#{e.backtrace.join("\n")}")
             error_response("Diagram generation failed: #{e.message}")
           end
         end
@@ -59,13 +61,25 @@ module Dbwatcher
 
         protected
 
-        # Render diagram from dataset (abstract method)
+        # Render diagram from dataset (template method)
         #
         # @param dataset [Dataset] standardized dataset
         # @return [Hash] diagram generation result
-        # @raise [NotImplementedError] if not implemented by subclass
         def render_diagram(dataset)
-          raise NotImplementedError, "Subclasses must implement render_diagram method"
+          log_debug("Rendering #{mermaid_diagram_type} diagram from dataset with " \
+                    "#{dataset.entities.size} entities and #{dataset.relationships.size} relationships")
+
+          # Generate diagram content directly from dataset
+          content = generate_diagram_content(dataset)
+          success_response(content, mermaid_diagram_type)
+        end
+
+        # Generate diagram content based on dataset (to be implemented by subclasses)
+        #
+        # @param dataset [Dataset] standardized dataset
+        # @return [String] diagram content
+        def generate_diagram_content(dataset)
+          raise NotImplementedError, "Subclasses must implement generate_diagram_content method"
         end
 
         # Build empty diagram with message
@@ -118,9 +132,9 @@ module Dbwatcher
         # @param operation [String] operation name
         # @param duration [Float] operation duration in seconds
         # @param context [Hash] additional context
-        def log_operation_completion(operation, duration, _context = {})
-          @logger.info("Strategy operation completed: #{operation} by #{self.class.name} " \
-                       "in #{(duration * 1000).round(2)}ms")
+        def log_operation_completion(operation, duration, context = {})
+          log_info("Strategy operation completed: #{operation} by #{self.class.name} " \
+                   "in #{(duration * 1000).round(2)}ms", context)
         end
 
         # Create default syntax builder

data/lib/dbwatcher/services/diagram_strategies/class_diagram_strategy.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "standard_diagram_strategy"
+
 module Dbwatcher
   module Services
     module DiagramStrategies
@@ -7,31 +9,10 @@ module Dbwatcher
       #
       # Handles class diagram generation by converting dataset entities and relationships
       # to Mermaid class diagram syntax.
-      class ClassDiagramStrategy < BaseDiagramStrategy
-        protected
-
-        # Render class diagram from standardized dataset
-        #
-        # @param dataset [Dataset] standardized dataset
-        # @return [Hash] diagram generation result
-        def render_diagram(dataset)
-          @logger.debug "Rendering class diagram from dataset with #{dataset.entities.size} entities and " \
-                        "#{dataset.relationships.size} relationships"
-
-          # Generate diagram content directly from dataset
-          content = if dataset.relationships.empty? && dataset.entities.empty?
-                      @syntax_builder.build_empty_class_diagram("No model associations or entities found")
-                    else
-                      @syntax_builder.build_class_diagram_from_dataset(dataset)
-                    end
-
-          success_response(content, "classDiagram")
-        end
-
+      class ClassDiagramStrategy < StandardDiagramStrategy
         private
 
         # Strategy metadata methods
-
         def strategy_name
           "Model Associations (Class Diagram)"
         end
@@ -43,6 +24,19 @@ module Dbwatcher
         def mermaid_diagram_type
           "classDiagram"
         end
+
+        # Diagram generation configuration
+        def empty_diagram_method
+          :build_empty_class_diagram
+        end
+
+        def empty_diagram_message
+          "No model associations or entities found"
+        end
+
+        def full_diagram_method
+          :build_class_diagram_from_dataset
+        end
       end
     end
   end

data/lib/dbwatcher/services/diagram_strategies/diagram_strategy_helpers.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Dbwatcher
+  module Services
+    module DiagramStrategies
+      # Helper module for diagram strategies
+      #
+      # Provides common utility methods for diagram strategies to reduce code duplication.
+      # These methods handle common patterns in diagram generation.
+      module DiagramStrategyHelpers
+        # Generate diagram content with empty state handling
+        #
+        # @param dataset [Dataset] standardized dataset
+        # @param options [Hash] options for diagram generation
+        # @option options [Symbol] :empty_method method to call for empty diagram
+        # @option options [String] :empty_message message for empty diagram
+        # @option options [Symbol] :empty_entities_method method to call for diagram with only entities
+        # @option options [Symbol] :full_diagram_method method to call for complete diagram
+        # @return [String] diagram content
+        def generate_standard_diagram_content(dataset, options)
+          if dataset.relationships.empty? && dataset.entities.empty?
+            @syntax_builder.send(options[:empty_method], options[:empty_message])
+          elsif dataset.relationships.empty? && options[:empty_entities_method]
+            # Show isolated entities if no relationships but entities exist
+            @syntax_builder.send(options[:empty_entities_method], dataset.entities.values)
+          else
+            @syntax_builder.send(options[:full_diagram_method], dataset)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dbwatcher/services/diagram_strategies/erd_diagram_strategy.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "standard_diagram_strategy"
+
 module Dbwatcher
   module Services
     module DiagramStrategies
@@ -7,34 +9,10 @@ module Dbwatcher
       #
       # Handles ERD diagram generation by converting dataset entities and relationships
       # to Mermaid ERD syntax.
-      class ErdDiagramStrategy < BaseDiagramStrategy
-        protected
-
-        # Render ERD diagram from standardized dataset
-        #
-        # @param dataset [Dataset] standardized dataset
-        # @return [Hash] diagram generation result
-        def render_diagram(dataset)
-          @logger.debug "Rendering ERD diagram from dataset with #{dataset.entities.size} entities and " \
-                        "#{dataset.relationships.size} relationships"
-
-          # Generate diagram content directly from dataset
-          content = if dataset.relationships.empty? && dataset.entities.empty?
-                      @syntax_builder.build_empty_erd("No database relationships or tables found")
-                    elsif dataset.relationships.empty?
-                      # Show isolated tables if no relationships but entities exist
-                      @syntax_builder.build_erd_diagram_with_tables(dataset.entities.values)
-                    else
-                      @syntax_builder.build_erd_diagram_from_dataset(dataset)
-                    end
-
-          success_response(content, "erDiagram")
-        end
-
+      class ErdDiagramStrategy < StandardDiagramStrategy
         private
 
         # Strategy metadata methods
-
         def strategy_name
           "Database Schema (ERD)"
         end
@@ -46,6 +24,23 @@ module Dbwatcher
         def mermaid_diagram_type
           "erDiagram"
         end
+
+        # Diagram generation configuration
+        def empty_diagram_method
+          :build_empty_erd
+        end
+
+        def empty_diagram_message
+          "No database relationships or tables found"
+        end
+
+        def empty_entities_method
+          :build_erd_diagram_with_tables
+        end
+
+        def full_diagram_method
+          :build_erd_diagram_from_dataset
+        end
       end
     end
   end

data/lib/dbwatcher/services/diagram_strategies/flowchart_diagram_strategy.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "standard_diagram_strategy"
+
 module Dbwatcher
   module Services
     module DiagramStrategies
@@ -7,34 +9,10 @@ module Dbwatcher
       #
       # Handles flowchart diagram generation by converting dataset entities and relationships
       # to Mermaid flowchart syntax.
-      class FlowchartDiagramStrategy < BaseDiagramStrategy
-        protected
-
-        # Render flowchart diagram from standardized dataset
-        #
-        # @param dataset [Dataset] standardized dataset
-        # @return [Hash] diagram generation result
-        def render_diagram(dataset)
-          @logger.debug "Rendering flowchart diagram from dataset with #{dataset.entities.size} entities and " \
-                        "#{dataset.relationships.size} relationships"
-
-          # Generate diagram content directly from dataset
-          content = if dataset.relationships.empty? && dataset.entities.empty?
-                      @syntax_builder.build_empty_flowchart("No model associations or entities found")
-                    elsif dataset.relationships.empty?
-                      # Show isolated nodes if no relationships but entities exist
-                      @syntax_builder.build_flowchart_with_nodes(dataset.entities.values)
-                    else
-                      @syntax_builder.build_flowchart_diagram_from_dataset(dataset)
-                    end
-
-          success_response(content, "flowchart")
-        end
-
+      class FlowchartDiagramStrategy < StandardDiagramStrategy
         private
 
         # Strategy metadata methods
-
         def strategy_name
           "Model Associations"
         end
@@ -46,6 +24,23 @@ module Dbwatcher
         def mermaid_diagram_type
           "flowchart"
         end
+
+        # Diagram generation configuration
+        def empty_diagram_method
+          :build_empty_flowchart
+        end
+
+        def empty_diagram_message
+          "No model associations or entities found"
+        end
+
+        def empty_entities_method
+          :build_flowchart_with_nodes
+        end
+
+        def full_diagram_method
+          :build_flowchart_diagram_from_dataset
+        end
       end
     end
   end

data/lib/dbwatcher/services/diagram_strategies/standard_diagram_strategy.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require_relative "base_diagram_strategy"
+require_relative "diagram_strategy_helpers"
+
+module Dbwatcher
+  module Services
+    module DiagramStrategies
+      # Standard diagram strategy implementation
+      #
+      # Provides a common implementation for diagram strategies that follow
+      # the standard pattern of generating diagrams from datasets.
+      # Specific strategies can inherit from this class and provide only
+      # the necessary configuration.
+      class StandardDiagramStrategy < BaseDiagramStrategy
+        include DiagramStrategyHelpers
+
+        # Initialize with configuration options
+        #
+        # @param dependencies [Hash] injected dependencies
+        # @option dependencies [Object] :syntax_builder Mermaid syntax builder
+        # @option dependencies [Logger] :logger logger instance
+        def initialize(dependencies = {})
+          super
+          @diagram_options = diagram_options
+        end
+
+        protected
+
+        # Generate diagram content from dataset using standard pattern
+        #
+        # @param dataset [Dataset] standardized dataset
+        # @return [String] diagram content
+        def generate_diagram_content(dataset)
+          generate_standard_diagram_content(dataset, @diagram_options)
+        end
+
+        # Get diagram generation options
+        #
+        # @return [Hash] diagram options
+        def diagram_options
+          {
+            empty_method: empty_diagram_method,
+            empty_message: empty_diagram_message,
+            empty_entities_method: empty_entities_method,
+            full_diagram_method: full_diagram_method
+          }
+        end
+
+        # Get method name for generating empty diagram
+        #
+        # @return [Symbol] method name
+        def empty_diagram_method
+          raise NotImplementedError, "Subclasses must implement empty_diagram_method"
+        end
+
+        # Get message for empty diagram
+        #
+        # @return [String] empty diagram message
+        def empty_diagram_message
+          "No data available for diagram"
+        end
+
+        # Get method name for generating diagram with only entities
+        #
+        # @return [Symbol] method name
+        def empty_entities_method
+          nil
+        end
+
+        # Get method name for generating full diagram
+        #
+        # @return [Symbol] method name
+        def full_diagram_method
+          raise NotImplementedError, "Subclasses must implement full_diagram_method"
+        end
+      end
+    end
+  end
+end

data/lib/dbwatcher/services/diagram_system.rb

@@ -29,6 +29,8 @@ require_relative "diagram_analyzers/model_association_analyzer"
 
 # Diagram strategies
 require_relative "diagram_strategies/base_diagram_strategy"
+require_relative "diagram_strategies/diagram_strategy_helpers"
+require_relative "diagram_strategies/standard_diagram_strategy"
 require_relative "diagram_strategies/erd_diagram_strategy"
 require_relative "diagram_strategies/class_diagram_strategy"
 require_relative "diagram_strategies/flowchart_diagram_strategy"
@@ -41,6 +43,13 @@ module Dbwatcher
     # Diagram System Module
     # Provides centralized access to diagram generation capabilities
     module DiagramSystem
+      extend Dbwatcher::Logging
+
+      # Explicitly set the component name for logging
+      def self.component_name
+        "DiagramSystem"
+      end
+
       # Get available diagram types
       #
       # @return [Array<String>] available diagram type names
@@ -54,7 +63,11 @@ module Dbwatcher
       # @param diagram_type [String] type of diagram to generate
       # @return [Hash] diagram generation result
       def self.generate(session_id, diagram_type = "database_tables")
-        DiagramGenerator.new(session_id, diagram_type).call
+        log_debug("Generating diagram of type #{diagram_type} for session #{session_id}")
+        generator = DiagramGenerator.new(session_id: session_id, diagram_type: diagram_type)
+        result = generator.call
+        log_debug("Diagram generation completed with success=#{result[:success]}")
+        result
       end
 
       # Check if diagram type is supported

data/lib/dbwatcher/services/mermaid_syntax/base_builder.rb

@@ -15,6 +15,8 @@ module Dbwatcher
       #     end
       #   end
       class BaseBuilder
+        include Dbwatcher::Logging
+
         # Initialize a new builder with configuration
         #
         # @param config [Hash] configuration options

data/lib/dbwatcher/services/mermaid_syntax/erd_builder.rb

@@ -70,7 +70,7 @@ module Dbwatcher
         # @param entity [DiagramData::Entity] entity to render
         # @return [Array<String>] entity definition lines
         def build_erd_entity(entity)
-          table_name = Sanitizer.table_name(entity.name, preserve_table_case?)
+          table_name = Sanitizer.table_name(entity.name)
           lines = ["    #{table_name} {"]
 
           # Add attributes if enabled and available
@@ -92,7 +92,7 @@ module Dbwatcher
         # @return [String] formatted entity name
         def format_entity_name(entity_id, dataset)
           entity_name = dataset.get_entity(entity_id)&.name || entity_id
-          Sanitizer.table_name(entity_name, preserve_table_case?)
+          Sanitizer.table_name(entity_name)
         end
 
         # Build relationship definition

data/lib/dbwatcher/services/mermaid_syntax/sanitizer.rb

@@ -48,22 +48,12 @@ module Dbwatcher
           # Sanitize table name for Mermaid ERD
           #
           # @param name [String] raw table name
-          # @param preserve_case [Boolean] whether to preserve original case
-          # @return [String] sanitized table name
-          def table_name(name, preserve_case = nil)
+          # @return [String] sanitized table name (preserves original case)
+          def table_name(name)
             return "UNKNOWN_TABLE" unless name.is_a?(String) && !name.empty?
 
-            preserve = if preserve_case.nil?
-                         Dbwatcher.configuration.diagram_preserve_table_case
-                       else
-                         preserve_case
-                       end
-
-            if preserve
-              name.to_s.gsub(/[^a-zA-Z0-9_]/, "_")
-            else
-              name.to_s.upcase.gsub(/[^A-Z0-9_]/, "_")
-            end
+            # Always preserve original case
+            name.to_s.gsub(/[^a-zA-Z0-9_]/, "_")
           end
 
           # Sanitize method name for Mermaid class diagrams

data/lib/dbwatcher/services/mermaid_syntax_builder.rb

@@ -15,6 +15,8 @@ module Dbwatcher
     #   content = builder.build_erd_diagram_from_dataset(dataset)
     #   # => "erDiagram\n    USERS ||--o{ ORDERS : user_id"
     class MermaidSyntaxBuilder
+      include Dbwatcher::Logging
+
       # Custom error classes
       class SyntaxValidationError < StandardError; end
       class UnsupportedDiagramTypeError < StandardError; end
@@ -40,8 +42,8 @@ module Dbwatcher
       # @param options [Hash] generation options
       # @return [String] Mermaid ERD syntax
       def build_erd_diagram_from_dataset(dataset, options = {})
-        @logger.debug "Building ERD diagram from dataset with #{dataset.entities.size} entities and " \
-                      "#{dataset.relationships.size} relationships"
+        log_debug("Building ERD diagram from dataset with #{dataset.entities.size} entities and " \
+                  "#{dataset.relationships.size} relationships")
 
         builder = MermaidSyntax::ErdBuilder.new(@config.merge(options))
         builder.build_from_dataset(dataset)
@@ -53,8 +55,8 @@ module Dbwatcher
       # @param options [Hash] generation options
       # @return [String] Mermaid class diagram syntax
       def build_class_diagram_from_dataset(dataset, options = {})
-        @logger.debug "Building class diagram from dataset with #{dataset.entities.size} entities and " \
-                      "#{dataset.relationships.size} relationships"
+        log_debug("Building class diagram from dataset with #{dataset.entities.size} entities and " \
+                  "#{dataset.relationships.size} relationships")
 
         builder = MermaidSyntax::ClassDiagramBuilder.new(@config.merge(options))
         builder.build_from_dataset(dataset)
@@ -66,8 +68,8 @@ module Dbwatcher
       # @param options [Hash] generation options
       # @return [String] Mermaid flowchart syntax
       def build_flowchart_diagram_from_dataset(dataset, options = {})
-        @logger.debug "Building flowchart diagram from dataset with #{dataset.entities.size} entities and " \
-                      "#{dataset.relationships.size} relationships"
+        log_debug("Building flowchart diagram from dataset with #{dataset.entities.size} entities and " \
+                  "#{dataset.relationships.size} relationships")
 
         builder = MermaidSyntax::FlowchartBuilder.new(@config.merge(options))
         builder.build_from_dataset(dataset)
@@ -125,7 +127,7 @@ module Dbwatcher
       # @param options [Hash] generation options
       # @return [String] Mermaid ERD syntax
       def build_erd_diagram_with_tables(entities, options = {})
-        @logger.debug "Building ERD diagram with #{entities.size} isolated tables"
+        log_debug("Building ERD diagram with #{entities.size} isolated tables")
 
         dataset = Dbwatcher::Services::DiagramData::Dataset.new
         entities.each { |entity| dataset.add_entity(entity) }
@@ -139,7 +141,7 @@ module Dbwatcher
       # @param options [Hash] generation options
       # @return [String] Mermaid flowchart syntax
       def build_flowchart_with_nodes(entities, options = {})
-        @logger.debug "Building flowchart diagram with #{entities.size} isolated nodes"
+        log_debug("Building flowchart diagram with #{entities.size} isolated nodes")
 
         dataset = Dbwatcher::Services::DiagramData::Dataset.new
         entities.each { |entity| dataset.add_entity(entity) }

data/lib/dbwatcher/services/system_info/runtime_info_collector.rb

@@ -136,7 +136,7 @@ module Dbwatcher
         #
         # @return [Hash] loaded gems with versions
         def collect_loaded_gems
-          return {} unless Dbwatcher.configuration.system_info_include_performance_metrics
+          return {} unless Dbwatcher.configuration.system_info_include_performance_metrics?
 
           gems = {}
           Gem.loaded_specs.each do |name, spec|
@@ -154,7 +154,7 @@ module Dbwatcher
         def collect_load_path_info
           {
             size: $LOAD_PATH.size,
-            paths: Dbwatcher.configuration.system_info_include_performance_metrics ? $LOAD_PATH.first(10) : []
+            paths: Dbwatcher.configuration.system_info_include_performance_metrics? ? $LOAD_PATH.first(10) : []
           }
         rescue StandardError => e
           log_error "Failed to get load path info: #{e.message}"
@@ -166,7 +166,7 @@ module Dbwatcher
         # @return [Hash] filtered environment variables
         # rubocop:disable Metrics/MethodLength
         def collect_environment_variables
-          return {} unless Dbwatcher.configuration.collect_sensitive_env_vars
+          return {} unless Dbwatcher.configuration.collect_sensitive_env_vars?
 
           env_vars = {}
 
@@ -280,14 +280,14 @@ module Dbwatcher
                 300
               end,
             collect_sensitive_env_vars:
-              if config.respond_to?(:collect_sensitive_env_vars)
-                config.collect_sensitive_env_vars
+              if config.respond_to?(:collect_sensitive_env_vars?)
+                config.collect_sensitive_env_vars?
               else
                 false
               end,
             system_info_include_performance_metrics:
-              if config.respond_to?(:system_info_include_performance_metrics)
-                config.system_info_include_performance_metrics
+              if config.respond_to?(:system_info_include_performance_metrics?)
+                config.system_info_include_performance_metrics?
               else
                 true
               end

data/lib/dbwatcher/services/system_info/system_info_collector.rb

@@ -77,7 +77,7 @@ module Dbwatcher
         #
         # @return [Hash] machine information or empty hash on error
         def collect_machine_info
-          return {} unless Dbwatcher.configuration.collect_system_info
+          return {} unless Dbwatcher.configuration.system_info
 
           MachineInfoCollector.call
         rescue StandardError => e
@@ -89,7 +89,7 @@ module Dbwatcher
         #
         # @return [Hash] database information or empty hash on error
         def collect_database_info
-          return {} unless Dbwatcher.configuration.collect_system_info
+          return {} unless Dbwatcher.configuration.system_info
 
           DatabaseInfoCollector.call
         rescue StandardError => e
@@ -101,7 +101,7 @@ module Dbwatcher
         #
         # @return [Hash] runtime information or empty hash on error
         def collect_runtime_info
-          return {} unless Dbwatcher.configuration.collect_system_info
+          return {} unless Dbwatcher.configuration.system_info
 
           RuntimeInfoCollector.call
         rescue StandardError => e

data/lib/dbwatcher/services/timeline_data_service/entry_builder.rb

@@ -66,7 +66,29 @@ module Dbwatcher
         # @param change [Hash] change data
         # @return [String, nil] record ID if available
         def extract_record_id(change)
-          change[:record_id] || change[:id] || change.dig(:changes, :id)
+          change[:record_id] || change[:id] || extract_id_from_changes(change[:changes])
+        end
+
+        # Extract ID from changes data (hash or array format)
+        #
+        # @param changes [Hash, Array, nil] changes data
+        # @return [String, nil] extracted ID
+        def extract_id_from_changes(changes)
+          return nil unless changes
+
+          case changes
+          when Hash then changes[:id]
+          when Array then extract_id_from_array_changes(changes)
+          end
+        end
+
+        # Extract ID from array of column changes
+        #
+        # @param changes [Array] array of column changes
+        # @return [String, nil] extracted ID value
+        def extract_id_from_array_changes(changes)
+          id_change = changes.find { |c| c.is_a?(Hash) && c[:column] == "id" }
+          id_change&.dig(:new_value) || id_change&.dig(:old_value)
         end
 
         # Format changes for timeline display

data/lib/dbwatcher/storage/session_storage.rb

@@ -282,14 +282,14 @@ module Dbwatcher
       #
       # @return [Boolean] true if cleanup is enabled
       def cleanup_enabled?
-        Dbwatcher.configuration.auto_clean_after_days&.positive?
+        Dbwatcher.configuration.auto_clean_days&.positive?
       end
 
       # Calculates cleanup cutoff date
       #
       # @return [Time] cutoff date for cleanup
       def calculate_cleanup_cutoff
-        days = Dbwatcher.configuration.auto_clean_after_days
+        days = Dbwatcher.configuration.auto_clean_days
         current_time - (days * 24 * 60 * 60)
       end
 

data/lib/dbwatcher/storage.rb

@@ -105,7 +105,7 @@ module Dbwatcher
       # retention period. This helps manage storage space usage.
       #
       # @return [void]
-      # @see Configuration#auto_clean_after_days
+      # @see Configuration#auto_clean_days
       def cleanup_old_sessions
         session_storage.cleanup_old_sessions
       end

data/lib/dbwatcher/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Dbwatcher
-  VERSION = "1.1.3"
+  VERSION = "1.1.5"
 end