newrelic_rpm 7.0.0 → 9.0.0

data/lib/new_relic/agent/instrumentation/active_record_helper.rb

@@ -1,8 +1,9 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 require 'new_relic/agent/datastores/metric_helper'
+require 'new_relic/constants'
 
 module NewRelic
   module Agent
@@ -18,15 +19,15 @@ module NewRelic
 
         def instrument_save_methods
           ::ActiveRecord::Base.class_eval do
-            alias_method :save_without_newrelic, :save
-            
+            alias_method(:save_without_newrelic, :save)
+
             def save(*args, &blk)
               ::NewRelic::Agent.with_database_metric_name(self.class.name, nil, ACTIVE_RECORD) do
                 save_without_newrelic(*args, &blk)
               end
             end
 
-            alias_method :save_without_newrelic!, :save!
+            alias_method(:save_without_newrelic!, :save!)
 
             def save!(*args, &blk)
               ::NewRelic::Agent.with_database_metric_name(self.class.name, nil, ACTIVE_RECORD) do
@@ -38,15 +39,15 @@ module NewRelic
 
         def instrument_relation_methods
           ::ActiveRecord::Relation.class_eval do
-            alias_method :update_all_without_newrelic, :update_all
+            alias_method(:update_all_without_newrelic, :update_all)
 
             def update_all(*args, &blk)
               ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
                 update_all_without_newrelic(*args, &blk)
               end
             end
-            
-            alias_method :delete_all_without_newrelic, :delete_all
+
+            alias_method(:delete_all_without_newrelic, :delete_all)
 
             if RUBY_VERSION < "2.7.0"
               def delete_all(*args, &blk)
@@ -62,7 +63,7 @@ module NewRelic
               end
             end
 
-            alias_method :destroy_all_without_newrelic, :destroy_all
+            alias_method(:destroy_all_without_newrelic, :destroy_all)
 
             def destroy_all(*args, &blk)
               ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
@@ -70,8 +71,7 @@ module NewRelic
               end
             end
 
-
-            alias_method :calculate_without_newrelic, :calculate
+            alias_method(:calculate_without_newrelic, :calculate)
 
             def calculate(*args, &blk)
               ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
@@ -79,9 +79,8 @@ module NewRelic
               end
             end
 
-
             if method_defined?(:pluck)
-              alias_method :pluck_without_newrelic, :pluck
+              alias_method(:pluck_without_newrelic, :pluck)
 
               def pluck(*args, &blk)
                 ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
@@ -94,32 +93,41 @@ module NewRelic
         end
 
         ACTIVE_RECORD = "ActiveRecord".freeze
-        OTHER         = "other".freeze
+        OTHER = "other".freeze
+        MAKARA_SUFFIX = "_makara".freeze
+
+        # convert vendor (makara, etc.) wrapper names to their bare names
+        # ex: postgresql_makara -> postgresql
+        def bare_adapter_name(adapter_name)
+          # TODO: OLD RUBIES - RUBY_VERSION < 2.5
+          # With Ruby 2.5+ we could use #delete_suffix instead of #chomp for a
+          # potential speed boost
+          return adapter_name.chomp(MAKARA_SUFFIX) if adapter_name && adapter_name.end_with?(MAKARA_SUFFIX)
+
+          adapter_name
+        end
 
-        def product_operation_collection_for name, sql, adapter_name
-          product   = map_product(adapter_name)
-          splits    = split_name(name)
-          model     = model_from_splits(splits)
+        def product_operation_collection_for(name, sql, adapter_name)
+          product = map_product(bare_adapter_name(adapter_name))
+          splits = split_name(name)
+          model = model_from_splits(splits)
           operation = operation_from_splits(splits, sql)
-          NewRelic::Agent::Datastores::MetricHelper.product_operation_collection_for product, operation, model, ACTIVE_RECORD
+          NewRelic::Agent::Datastores::MetricHelper.product_operation_collection_for(product, operation, model, ACTIVE_RECORD)
         end
 
         SPACE = ' '.freeze
-        EMPTY = [].freeze
 
         def split_name(name)
           if name && name.respond_to?(:split)
             name.split(SPACE)
           else
-            EMPTY
+            NewRelic::EMPTY_ARRAY
           end
         end
 
         def model_from_splits(splits)
           if splits.length == 2
             splits.first
-          else
-            nil
           end
         end
 
@@ -135,16 +143,16 @@ module NewRelic
         # known operations coming in. Anything not matching the list is fine,
         # it just needs to get downcased directly for use.
         OPERATION_NAMES = {
-          'Find'    => 'find',
-          'Load'    => 'find',
-          'Count'   => 'find',
-          'Exists'  => 'find',
-          'Create'  => 'create',
+          'Find' => 'find',
+          'Load' => 'find',
+          'Count' => 'find',
+          'Exists' => 'find',
+          'Create' => 'create',
           'Columns' => 'columns',
           'Indexes' => 'indexes',
           'Destroy' => 'destroy',
-          'Update'  => 'update',
-          'Save'    => 'save'
+          'Update' => 'update',
+          'Save' => 'save'
         }.freeze
 
         def map_operation(raw_operation)
@@ -155,41 +163,41 @@ module NewRelic
         end
 
         PRODUCT_NAMES = {
-          "mysql"      => "MySQL",
-          "mysql2"     => "MySQL",
+          "mysql" => "MySQL",
+          "mysql2" => "MySQL",
 
           "postgresql" => "Postgres",
 
-          "sqlite3"    => "SQLite",
+          "sqlite3" => "SQLite",
 
           # https://rubygems.org/gems/activerecord-jdbcpostgresql-adapter
-          "jdbcmysql"  => "MySQL",
+          "jdbcmysql" => "MySQL",
 
           # https://rubygems.org/gems/activerecord-jdbcpostgresql-adapter
           "jdbcpostgresql" => "Postgres",
-          
+
           # https://rubygems.org/gems/activerecord-postgis-adapter
-          "postgis"    => "Postgres",
+          "postgis" => "Postgres",
 
           # https://rubygems.org/gems/activerecord-jdbcsqlite3-adapter
-          "jdbcsqlite3"    => "SQLite",
+          "jdbcsqlite3" => "SQLite",
 
           # https://rubygems.org/gems/activerecord-jdbcderby-adapter
-          "derby"      => "Derby",
-          "jdbcderby"  => "Derby",
+          "derby" => "Derby",
+          "jdbcderby" => "Derby",
 
           # https://rubygems.org/gems/activerecord-jdbc-adapter
-          "jdbc"       => "JDBC",
+          "jdbc" => "JDBC",
 
           # https://rubygems.org/gems/activerecord-jdbcmssql-adapter
-          "jdbcmssql"  => "MSSQL",
-          "mssql"      => "MSSQL",
+          "jdbcmssql" => "MSSQL",
+          "mssql" => "MSSQL",
 
           # https://rubygems.org/gems/activerecord-sqlserver-adapter
-          "sqlserver"  => "MSSQL",
+          "sqlserver" => "MSSQL",
 
           # https://rubygems.org/gems/activerecord-odbc-adapter
-          "odbc"       => "ODBC",
+          "odbc" => "ODBC",
 
           # https://rubygems.org/gems/activerecord-oracle_enhanced-adapter
           "oracle_enhanced" => "Oracle"
@@ -198,25 +206,24 @@ module NewRelic
         ACTIVE_RECORD_DEFAULT_PRODUCT_NAME = "ActiveRecord".freeze
 
         def map_product(adapter_name)
-          PRODUCT_NAMES.fetch(adapter_name,
-                              ACTIVE_RECORD_DEFAULT_PRODUCT_NAME)
+          PRODUCT_NAMES.fetch(adapter_name, ACTIVE_RECORD_DEFAULT_PRODUCT_NAME)
         end
 
         module InstanceIdentification
           extend self
 
           PRODUCT_SYMBOLS = {
-            "mysql"      => :mysql,
-            "mysql2"     => :mysql,
-            "jdbcmysql"  => :mysql,
+            "mysql" => :mysql,
+            "mysql2" => :mysql,
+            "jdbcmysql" => :mysql,
 
-            "postgresql"     => :postgres,
+            "postgresql" => :postgres,
             "jdbcpostgresql" => :postgres,
-            "postgis"        => :postgres
+            "postgis" => :postgres
           }.freeze
 
           DATASTORE_DEFAULT_PORTS = {
-            :mysql    => "3306",
+            :mysql => "3306",
             :postgres => "5432"
           }.freeze
 
@@ -225,13 +232,18 @@ module NewRelic
           SLASH = "/".freeze
           LOCALHOST = "localhost".freeze
 
+          def adapter_from_config(config)
+            bare_name = NewRelic::Agent::Instrumentation::ActiveRecordHelper.bare_adapter_name(config[:adapter])
+            PRODUCT_SYMBOLS[bare_name]
+          end
+
           def host(config)
             return UNKNOWN unless config
 
-            configured_value  = config[:host]
-            adapter = PRODUCT_SYMBOLS[config[:adapter]]
+            configured_value = config[:host]
+            adapter = adapter_from_config(config)
             if configured_value.nil? ||
-              postgres_unix_domain_socket_case?(configured_value, adapter)
+                postgres_unix_domain_socket_case?(configured_value, adapter)
 
               LOCALHOST
             elsif configured_value.empty?
@@ -239,16 +251,15 @@ module NewRelic
             else
               configured_value
             end
-
           rescue => e
-            NewRelic::Agent.logger.debug "Failed to retrieve ActiveRecord host: #{e}"
+            NewRelic::Agent.logger.debug("Failed to retrieve ActiveRecord host: #{e}")
             UNKNOWN
           end
 
           def port_path_or_id(config)
             return UNKNOWN unless config
 
-            adapter = PRODUCT_SYMBOLS[config[:adapter]]
+            adapter = adapter_from_config(config)
             if config[:socket]
               config[:socket].empty? ? UNKNOWN : config[:socket]
             elsif postgres_unix_domain_socket_case?(config[:host], adapter) || mysql_default_case?(config, adapter)
@@ -260,16 +271,15 @@ module NewRelic
             else
               UNKNOWN
             end
-
           rescue => e
-            NewRelic::Agent.logger.debug "Failed to retrieve ActiveRecord port_path_or_id: #{e}"
+            NewRelic::Agent.logger.debug("Failed to retrieve ActiveRecord port_path_or_id: #{e}")
             UNKNOWN
           end
 
           SUPPORTED_ADAPTERS = [:mysql, :postgres].freeze
 
-          def supported_adapter? config
-            config && SUPPORTED_ADAPTERS.include?(PRODUCT_SYMBOLS[config[:adapter]])
+          def supported_adapter?(config)
+            config && SUPPORTED_ADAPTERS.include?(adapter_from_config(config))
           end
 
           private

data/lib/new_relic/agent/instrumentation/active_record_notifications.rb

@@ -1,11 +1,10 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 require 'new_relic/agent/instrumentation/active_record_subscriber'
 require 'new_relic/agent/instrumentation/active_record_prepend'
 
-
 # Provides a way to send :connection through ActiveSupport notifications to avoid
 # looping through connection handlers to locate a connection by connection_id
 # This is not needed in Rails 6+: https://github.com/rails/rails/pull/34602
@@ -20,12 +19,13 @@ module NewRelic
           def log(sql, name = "SQL", binds = [], statement_name = nil)
             @instrumenter.instrument(
               SQL_ACTIVE_RECORD,
-              :sql            => sql,
-              :name           => name,
-              :connection_id  => object_id,
-              :connection     => self,
+              :sql => sql,
+              :name => name,
+              :connection_id => object_id,
+              :connection => self,
               :statement_name => statement_name,
-              :binds          => binds) { yield }
+              :binds => binds
+            ) { yield }
           rescue => e
             # The translate_exception_class method got introduced in 4.1
             if ::ActiveRecord::VERSION::MINOR == 0
@@ -41,13 +41,14 @@ module NewRelic
           def log(sql, name = "SQL", binds = [], type_casted_binds = [], statement_name = nil)
             @instrumenter.instrument(
               SQL_ACTIVE_RECORD,
-              sql:               sql,
-              name:              name,
-              binds:             binds,
+              sql: sql,
+              name: name,
+              binds: binds,
               type_casted_binds: type_casted_binds,
-              statement_name:    statement_name,
-              connection_id:     object_id,
-              connection:        self) { yield }
+              statement_name: statement_name,
+              connection_id: object_id,
+              connection: self
+            ) { yield }
           rescue => e
             raise translate_exception_class(e, sql)
           end
@@ -58,17 +59,18 @@ module NewRelic
           def log(sql, name = "SQL", binds = [], type_casted_binds = [], statement_name = nil) # :doc:
             @instrumenter.instrument(
               SQL_ACTIVE_RECORD,
-              sql:               sql,
-              name:              name,
-              binds:             binds,
+              sql: sql,
+              name: name,
+              binds: binds,
               type_casted_binds: type_casted_binds,
-              statement_name:    statement_name,
-              connection_id:     object_id,
-              connection:        self) do
-                @lock.synchronize do
-                  yield
-                end
+              statement_name: statement_name,
+              connection_id: object_id,
+              connection: self
+            ) do
+              @lock.synchronize do
+                yield
               end
+            end
           rescue => e
             raise translate_exception_class(e, sql)
           end
@@ -82,9 +84,9 @@ DependencyDetection.defer do
   named :active_record_notifications
 
   depends_on do
-    defined?(::ActiveRecord) && defined?(::ActiveRecord::Base) &&
-      defined?(::ActiveRecord::VERSION) &&
-      ::ActiveRecord::VERSION::MAJOR.to_i >= 4
+    defined?(ActiveRecord) && defined?(ActiveRecord::Base) &&
+      defined?(ActiveRecord::VERSION) &&
+      ActiveRecord::VERSION::MAJOR.to_i >= 4
   end
 
   depends_on do
@@ -93,7 +95,7 @@ DependencyDetection.defer do
   end
 
   executes do
-    ::NewRelic::Agent.logger.info 'Installing notifications based Active Record instrumentation'
+    NewRelic::Agent.logger.info('Installing notifications based Active Record instrumentation')
   end
 
   executes do
@@ -103,50 +105,51 @@ DependencyDetection.defer do
 
   executes do
     ActiveSupport.on_load(:active_record) do
-      ::NewRelic::Agent::PrependSupportability.record_metrics_for(
-          ::ActiveRecord::Base,
-          ::ActiveRecord::Relation)
+      NewRelic::Agent::PrependSupportability.record_metrics_for(
+        ActiveRecord::Base,
+        ActiveRecord::Relation
+      )
 
       # Default to .prepending, unless the ActiveRecord version is <=4
       # **AND** the :prepend_active_record_instrumentation config is false
-      if ::ActiveRecord::VERSION::MAJOR > 4 \
-          || ::NewRelic::Agent.config[:prepend_active_record_instrumentation]
+      if ActiveRecord::VERSION::MAJOR > 4 \
+          || NewRelic::Agent.config[:prepend_active_record_instrumentation]
 
-        ::ActiveRecord::Base.send(:prepend,
-            ::NewRelic::Agent::Instrumentation::ActiveRecordPrepend::BaseExtensions)
-        ::ActiveRecord::Relation.send(:prepend,
-            ::NewRelic::Agent::Instrumentation::ActiveRecordPrepend::RelationExtensions)
+        ActiveRecord::Base.send(:prepend,
+          NewRelic::Agent::Instrumentation::ActiveRecordPrepend::BaseExtensions)
+        ActiveRecord::Relation.send(:prepend,
+          NewRelic::Agent::Instrumentation::ActiveRecordPrepend::RelationExtensions)
       else
-        ::NewRelic::Agent::Instrumentation::ActiveRecordHelper.instrument_additional_methods
+        NewRelic::Agent::Instrumentation::ActiveRecordHelper.instrument_additional_methods
       end
     end
   end
 
   executes do
     if NewRelic::Agent.config[:backport_fast_active_record_connection_lookup]
-      major_version = ::ActiveRecord::VERSION::MAJOR.to_i
-      minor_version = ::ActiveRecord::VERSION::MINOR.to_i
+      major_version = ActiveRecord::VERSION::MAJOR.to_i
+      minor_version = ActiveRecord::VERSION::MINOR.to_i
 
       activerecord_extension = if major_version == 4
-        ::NewRelic::Agent::Instrumentation::ActiveRecordNotifications::BaseExtensions4x
+        NewRelic::Agent::Instrumentation::ActiveRecordNotifications::BaseExtensions4x
       elsif major_version == 5 && minor_version == 0
-        ::NewRelic::Agent::Instrumentation::ActiveRecordNotifications::BaseExtensions50
+        NewRelic::Agent::Instrumentation::ActiveRecordNotifications::BaseExtensions50
       elsif major_version == 5 && minor_version == 1
-        ::NewRelic::Agent::Instrumentation::ActiveRecordNotifications::BaseExtensions51
+        NewRelic::Agent::Instrumentation::ActiveRecordNotifications::BaseExtensions51
       end
 
       unless activerecord_extension.nil?
-        ::ActiveRecord::ConnectionAdapters::AbstractAdapter.send(:prepend, activerecord_extension)
+        ActiveRecord::ConnectionAdapters::AbstractAdapter.send(:prepend, activerecord_extension)
       end
     end
   end
 
   executes do
-    if ::ActiveRecord::VERSION::MAJOR == 5 \
-        && ::ActiveRecord::VERSION::MINOR.to_i == 1 \
-        && ::ActiveRecord::VERSION::TINY.to_i >= 6
+    if ActiveRecord::VERSION::MAJOR == 5 \
+        && ActiveRecord::VERSION::MINOR.to_i == 1 \
+        && ActiveRecord::VERSION::TINY.to_i >= 6
 
-      ::ActiveRecord::Base.prepend ::NewRelic::Agent::Instrumentation::ActiveRecordPrepend::BaseExtensions516
+      ActiveRecord::Base.prepend(NewRelic::Agent::Instrumentation::ActiveRecordPrepend::BaseExtensions516)
     end
   end
 end

data/lib/new_relic/agent/instrumentation/active_record_prepend.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 require 'new_relic/agent/prepend_supportability'
 
@@ -11,13 +11,13 @@ module NewRelic
         ACTIVE_RECORD = 'ActiveRecord'.freeze
 
         module BaseExtensions
-
           if RUBY_VERSION < "2.7.0"
             def save(*args, &blk)
               ::NewRelic::Agent.with_database_metric_name(self.class.name, nil, ACTIVE_RECORD) do
                 super
               end
             end
+
             def save!(*args, &blk)
               ::NewRelic::Agent.with_database_metric_name(self.class.name, nil, ACTIVE_RECORD) do
                 super
@@ -30,11 +30,12 @@ module NewRelic
                 super
               end
             end
+
             def save!(*args, **kwargs, &blk)
               ::NewRelic::Agent.with_database_metric_name(self.class.name, nil, ACTIVE_RECORD) do
                 super
               end
-            end  
+            end
 
           end
         end
@@ -58,7 +59,6 @@ module NewRelic
               end
             end
           end
-
         end
 
         module RelationExtensions

data/lib/new_relic/agent/instrumentation/active_record_subscriber.rb

@@ -1,6 +1,7 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
 require 'new_relic/agent/instrumentation/active_record_helper'
 require 'new_relic/agent/instrumentation/notifications_subscriber'
 
@@ -43,7 +44,7 @@ module NewRelic
           end
         end
 
-        def start(name, id, payload) #THREAD_LOCAL_ACCESS
+        def start(name, id, payload) # THREAD_LOCAL_ACCESS
           return if cached?(payload)
           return unless NewRelic::Agent.tl_is_execution_traced?
 
@@ -54,7 +55,7 @@ module NewRelic
           log_notification_error(e, name, 'start')
         end
 
-        def finish(name, id, payload) #THREAD_LOCAL_ACCESS
+        def finish(name, id, payload) # THREAD_LOCAL_ACCESS
           return if cached?(payload)
           return unless state.is_execution_traced?
 
@@ -64,7 +65,6 @@ module NewRelic
             end
             segment.finish
           end
-
         rescue => e
           log_notification_error(e, name, 'finish')
         end
@@ -72,20 +72,18 @@ module NewRelic
         def get_explain_plan(statement)
           connection = NewRelic::Agent::Database.get_connection(statement.config) do
             ::ActiveRecord::Base.send("#{statement.config[:adapter]}_connection",
-                                      statement.config)
+              statement.config)
           end
           if connection && connection.respond_to?(:exec_query)
             return connection.exec_query("EXPLAIN #{statement.sql}",
-                                         "Explain #{statement.name}",
-                                         statement.binds)
+              "Explain #{statement.name}",
+              statement.binds)
           end
         rescue => e
-          NewRelic::Agent.logger.debug "Couldn't fetch the explain plan for #{statement} due to #{e}"
+          NewRelic::Agent.logger.debug("Couldn't fetch the explain plan for #{statement} due to #{e}")
         end
 
         def active_record_config(payload)
-          return unless payload[:connection_id]
-
           # handle if the notification payload provides the AR connection
           # available in Rails 6+ & our ActiveRecordNotifications#log extension
           if payload[:connection]
@@ -93,22 +91,31 @@ module NewRelic
             return connection_config if connection_config
           end
 
-          connection = nil
-          connection_id = payload[:connection_id]
+          return unless connection_id = payload[:connection_id]
 
           ::ActiveRecord::Base.connection_handler.connection_pool_list.each do |handler|
-            connection = handler.connections.detect do |conn|
-              conn.object_id == connection_id
-            end
-
-            break if connection
+            connection = handler.connections.detect { |conn| conn.object_id == connection_id }
+            return connection.instance_variable_get(:@config) if connection
+
+            # when using makara, handler.connections will be empty, so use the
+            # spec config instead.
+            # https://github.com/newrelic/newrelic-ruby-agent/issues/507
+            # thank you @lucasklaassen
+            return handler.spec.config if use_spec_config?(handler)
           end
 
-          connection.instance_variable_get(:@config) if connection
+          nil
+        end
+
+        def use_spec_config?(handler)
+          handler.respond_to?(:spec) &&
+            handler.spec &&
+            handler.spec.config &&
+            handler.spec.config[:adapter].end_with?('makara')
         end
 
         def start_segment(config, payload)
-          sql = Helper.correctly_encoded payload[:sql]
+          sql = Helper.correctly_encoded(payload[:sql])
           product, operation, collection = ActiveRecordHelper.product_operation_collection_for(
             payload[:name],
             sql,
@@ -132,7 +139,7 @@ module NewRelic
             port_path_or_id: port_path_or_id,
             database_name: database)
 
-          segment._notice_sql sql, config, @explainer, payload[:binds], payload[:name]
+          segment._notice_sql(sql, config, @explainer, payload[:binds], payload[:name])
           segment
         end
       end

data/lib/new_relic/agent/instrumentation/active_storage.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 require 'new_relic/agent/instrumentation/active_storage_subscriber'
 
@@ -8,12 +8,16 @@ DependencyDetection.defer do
   named :active_storage
 
   depends_on do
-    defined?(::ActiveStorage) &&
+    !NewRelic::Agent.config[:disable_active_storage]
+  end
+
+  depends_on do
+    defined?(ActiveStorage) &&
       !NewRelic::Agent::Instrumentation::ActiveStorageSubscriber.subscribed?
   end
 
   executes do
-    ::NewRelic::Agent.logger.info 'Installing ActiveStorage 5 instrumentation'
+    NewRelic::Agent.logger.info('Installing ActiveStorage instrumentation')
   end
 
   executes do