solarwinds_apm 5.0.0

data/lib/solarwinds_apm/inst/bunny-client.rb

@@ -0,0 +1,157 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module SolarWindsAPM
+  module Inst
+    module BunnyExchange
+      include SolarWindsAPM::SDK::TraceContextHeaders
+
+      def self.included(klass)
+        SolarWindsAPM::Util.method_alias(klass, :delete, ::Bunny::Exchange)
+      end
+
+      def delete_with_sw_apm(opts = {})
+        # If we're not tracing, just do a fast return.
+        return delete_without_sw_apm(opts) if !SolarWindsAPM.tracing?
+
+        begin
+          kvs = {}
+          kvs[:Spec] = :pushq
+          kvs[:Flavor] = :rabbitmq
+          kvs[:Op] = :delete
+          kvs[:ExchangeType]   = @type
+          kvs[:RemoteHost]     = channel.connection.host
+          kvs[:RemotePort]     = channel.connection.port.to_i
+          kvs[:VirtualHost] = channel.connection.vhost
+
+          if @name.is_a?(String) && !@name.empty?
+            kvs[:ExchangeName] = @name
+          else
+            kvs[:ExchangeName] = :default
+          end
+
+          SolarWindsAPM::API.log_entry(:'rabbitmq-client')
+          delete_without_sw_apm(opts)
+        rescue => e
+          SolarWindsAPM::API.log_exception(:'rabbitmq-client', e)
+          raise e
+        ensure
+          kvs[:Backtrace] = SolarWindsAPM::API.backtrace if SolarWindsAPM::Config[:bunnyclient][:collect_backtraces]
+          SolarWindsAPM::API.log_exit(:'rabbitmq-client', kvs)
+        end
+      end
+    end
+
+    module BunnyChannel
+      include SolarWindsAPM::SDK::TraceContextHeaders
+
+      def self.included(klass)
+        SolarWindsAPM::Util.method_alias(klass, :basic_publish,     ::Bunny::Channel)
+        SolarWindsAPM::Util.method_alias(klass, :queue,             ::Bunny::Channel)
+        SolarWindsAPM::Util.method_alias(klass, :wait_for_confirms, ::Bunny::Channel)
+      end
+
+      def collect_channel_kvs
+        kvs = {}
+        kvs[:Spec] = :pushq
+        kvs[:Flavor] = :rabbitmq
+        kvs[:RemoteHost] = @connection.host
+        kvs[:RemotePort] = @connection.port.to_i
+        kvs[:VirtualHost] = @connection.vhost
+        kvs
+      rescue => e
+        SolarWindsAPM.logger.debug "[solarwinds_apm/debug] #{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}" if SolarWindsAPM::Config[:verbose]
+      ensure
+        return kvs
+      end
+
+      def basic_publish_with_sw_apm(payload, exchange, routing_key, opts = {})
+        # If we're not tracing, just do a fast return.
+        return basic_publish_without_sw_apm(payload, exchange, routing_key, opts) if !SolarWindsAPM.tracing?
+
+        begin
+          kvs = collect_channel_kvs
+
+          if exchange.respond_to?(:name)
+            kvs[:ExchangeName] = exchange.name
+          elsif exchange.respond_to?(:empty?) && !exchange.empty?
+            kvs[:ExchangeName] = exchange
+          else
+            kvs[:ExchangeName] = :default
+          end
+
+          kvs[:Queue]       = opts[:queue] if opts.key?(:queue)
+          kvs[:RoutingKey]  = routing_key if routing_key
+          kvs[:Op]          = :publish
+
+          SolarWindsAPM::API.log_entry(:'rabbitmq-client')
+          # Pass the tracing context as a header
+          opts[:headers] ||= {}
+          opts[:headers][:SourceTrace] = SolarWindsAPM::Context.toString
+          add_tracecontext_headers(opts[:headers])
+
+          basic_publish_without_sw_apm(payload, exchange, routing_key, opts)
+        rescue => e
+          SolarWindsAPM::API.log_exception(:'rabbitmq-client', e)
+          raise e
+        ensure
+          kvs[:Backtrace] = SolarWindsAPM::API.backtrace if SolarWindsAPM::Config[:bunnyclient][:collect_backtraces]
+          SolarWindsAPM::API.log_exit(:'rabbitmq-client', kvs)
+        end
+      end
+
+      def queue_with_sw_apm(name = AMQ::Protocol::EMPTY_STRING, opts = {})
+        # If we're not tracing, just do a fast return.
+        return queue_without_sw_apm(name, opts) if !SolarWindsAPM.tracing?
+
+        begin
+          kvs = collect_channel_kvs
+          kvs[:Op] = :queue
+
+          SolarWindsAPM::API.log_entry(:'rabbitmq-client')
+          opts[:headers] ||= {}
+          add_tracecontext_headers(opts[:headers])
+
+          result = queue_without_sw_apm(name, opts)
+          kvs[:Queue] = result.name
+          result
+        rescue => e
+          SolarWindsAPM::API.log_exception(:'rabbitmq-client', e)
+          raise e
+        ensure
+          kvs[:Backtrace] = SolarWindsAPM::API.backtrace if SolarWindsAPM::Config[:bunnyclient][:collect_backtraces]
+          SolarWindsAPM::API.log_exit(:'rabbitmq-client', kvs)
+        end
+      end
+
+      def wait_for_confirms_with_sw_apm
+        # If we're not tracing, just do a fast return.
+        return wait_for_confirms_without_sw_apm if !SolarWindsAPM.tracing?
+
+        begin
+          kvs = collect_channel_kvs
+          kvs[:Op] = :wait_for_confirms
+
+          SolarWindsAPM::API.log_entry(:'rabbitmq-client')
+          # can't continue trace for wait on consumer, because we can't send opts for wait
+          # Seems ok, since this is waiting client side
+          # and not actually spending time on the consumer
+
+          wait_for_confirms_without_sw_apm
+        rescue => e
+          SolarWindsAPM::API.log_exception(:'rabbitmq-client', e)
+          raise e
+        ensure
+          kvs[:Backtrace] = SolarWindsAPM::API.backtrace if SolarWindsAPM::Config[:bunnyclient][:collect_backtraces]
+          SolarWindsAPM::API.log_exit(:'rabbitmq-client', kvs)
+        end
+      end
+    end
+  end
+end
+
+if defined?(Bunny) && SolarWindsAPM::Config[:bunnyclient][:enabled]
+  SolarWindsAPM.logger.info '[solarwinds_apm/loading] Instrumenting bunny client' if SolarWindsAPM::Config[:verbose]
+  SolarWindsAPM::Util.send_include(Bunny::Exchange, SolarWindsAPM::Inst::BunnyExchange)
+  SolarWindsAPM::Util.send_include(Bunny::Channel, SolarWindsAPM::Inst::BunnyChannel)
+end

data/lib/solarwinds_apm/inst/bunny-consumer.rb

@@ -0,0 +1,102 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module SolarWindsAPM
+  module Inst
+    module BunnyConsumer
+      include SolarWindsAPM::SDK::TraceContextHeaders
+
+      def self.included(klass)
+        SolarWindsAPM::Util.method_alias(klass, :call, ::Bunny::Consumer)
+      end
+
+      def collect_consumer_kvs(args)
+        kvs = {}
+        kvs[:Spec] = :job
+        kvs[:Flavor] = :rabbitmq
+        kvs[:RemoteHost] = @channel.connection.host
+        kvs[:RemotePort] = @channel.connection.port.to_i
+        kvs[:VirtualHost] = @channel.connection.vhost
+
+        mp = args[1]
+        kvs[:RoutingKey] = args[0].routing_key if args[0].routing_key
+        kvs[:MsgID] = args[1].message_id if mp.message_id
+        kvs[:AppID] = args[1].app_id if mp.app_id
+        kvs[:Priority] = args[1].priority if mp.priority
+
+        if @queue.respond_to?(:name)
+          kvs[:Queue] = @queue.name
+        else
+          kvs[:Queue] = @queue
+        end
+
+        # Report configurable Controller/Action KVs
+        # See SolarWindsAPM::Config[:bunnyconsumer] in lib/solarwinds_apm/config.rb
+        # Used for dashboard trace filtering
+        controller_key = SolarWindsAPM::Config[:bunnyconsumer][:controller]
+        if mp.respond_to?(controller_key)
+          value = mp.method(controller_key).call
+          kvs[:Controller] = value if value
+        end
+
+        action_key = SolarWindsAPM::Config[:bunnyconsumer][:action]
+        if mp.respond_to?(action_key)
+          value = mp.method(action_key).call
+          kvs[:Action] = value if value
+        end
+
+        if kvs[:Queue]
+          kvs[:URL] = "/bunny/#{kvs[:Queue]}"
+        else
+          kvs[:URL] = "/bunny/consumer"
+        end
+
+        if SolarWindsAPM::Config[:bunnyconsumer][:log_args] && @arguments
+          kvs[:Args] = @arguments.to_s
+        end
+
+        kvs[:Backtrace] = SolarWindsAPM::API.backtrace if SolarWindsAPM::Config[:bunnyconsumer][:collect_backtraces]
+
+        kvs
+      rescue => e
+        SolarWindsAPM.logger.debug "[solarwinds_apm/debug] #{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}" if SolarWindsAPM::Config[:verbose]
+      ensure
+        return kvs
+      end
+
+      def call_with_sw_apm(*args)
+        report_kvs = collect_consumer_kvs(args)
+
+        # TODO all of this (to the next empty line) can be removed
+        #  once all of our agents (actually only Node) use w3c-header for RabbitMQ
+        #  w3c headers are read and added by the logging code
+        # If SourceTrace was passed:
+        # - capture it, report it
+        # - and add it as traceparent and tracestate header for use by start_trace
+        headers = args[1][:headers]
+        if headers && headers['SourceTrace']
+          report_kvs[:SourceTrace] = headers['SourceTrace']
+          # Remove SourceTrace
+          headers.delete('SourceTrace')
+          unless headers['traceparent'] && headers['tracestate']
+            add_tracecontext_headers(headers)
+          end
+        end
+
+        # the context either gets propagated via w3c headers
+        # or a new one should be started
+        # lets clear any context that may exist
+        # TODO revert with NH-11132
+        SolarWindsAPM::Context.clear
+        SolarWindsAPM::SDK.start_trace(:'rabbitmq-consumer', kvs: report_kvs, headers: headers) do
+          call_without_sw_apm(*args)
+        end
+      end
+    end
+  end
+end
+
+if SolarWindsAPM::Config[:bunnyconsumer][:enabled] && defined?(Bunny)
+  SolarWindsAPM.logger.info '[solarwinds_apm/loading] Instrumenting bunny consumer' if SolarWindsAPM::Config[:verbose]
+  SolarWindsAPM::Util.send_include(Bunny::Consumer, SolarWindsAPM::Inst::BunnyConsumer)
+end

data/lib/solarwinds_apm/inst/curb.rb

@@ -0,0 +1,288 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module SolarWindsAPM
+  module Inst
+
+    # Curb instrumentation wraps instance and class methods in two classes:
+    # Curl::Easy and Curl::Multi.  This CurlUtility module is used as a common module
+    # to be shared among both modules.
+    module CurlUtility
+      include SolarWindsAPM::SDK::TraceContextHeaders
+
+      private
+      ##
+      # sw_apm_collect
+      #
+      # Used as a central area to retrieve and return values
+      # that we're interesting in reporting to SolarWindsAPM
+      #
+      def sw_apm_collect(verb = nil)
+        kvs = {}
+
+        kvs[:Spec] = 'rsc'
+        kvs[:IsService] = 1
+
+        # Conditionally log query args
+        if SolarWindsAPM::Config[:curb][:log_args]
+          kvs[:RemoteURL] = url
+        else
+          kvs[:RemoteURL] = url.split('?').first
+        end
+
+        kvs[:HTTPMethod] = verb if verb
+
+        kvs
+      rescue => e
+        SolarWindsAPM.logger.debug "[solarwinds_apm/debug] Error capturing curb KVs: #{e.message}"
+        if SolarWindsAPM::Config[:verbose]
+          SolarWindsAPM.logger.debug "[solarwinds_apm/debug] #{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}"
+          SolarWindsAPM.logger.debug e.backtrace.join('\n')
+        end
+      ensure
+        return kvs
+      end
+
+      ##
+      # trace_curb_method
+      #
+      # An agnostic method that will profile any Curl::Easy method (and optional args and block)
+      # that you throw at it.
+      #
+      def trace_curb_method(kvs, method, args, &block)
+        # If we're not tracing, just do a fast return.
+        unless SolarWindsAPM.tracing?
+          add_tracecontext_headers(self.headers)
+          return self.send(method, args, &block)
+        end
+
+        begin
+          kvs.merge! sw_apm_collect
+
+          SolarWindsAPM::API.log_entry(:curb, kvs)
+          kvs.clear
+
+          # The core curb call
+          add_tracecontext_headers(self.headers)
+          response = self.send(method, *args, &block)
+
+          kvs[:HTTPStatus] = response_code
+
+          # If we get a redirect, report the location header
+          if ((300..308).to_a.include? response_code) && headers.key?("Location")
+            kvs[:Location] = headers["Location"]
+          end
+
+          response
+        rescue => e
+          SolarWindsAPM::API.log_exception(:curb, e)
+          raise e
+        ensure
+          kvs[:Backtrace] = SolarWindsAPM::API.backtrace if SolarWindsAPM::Config[:curb][:collect_backtraces]
+          SolarWindsAPM::API.log_exit(:curb, kvs)
+        end
+      end
+      
+    end # CurlUtility
+
+    # Instrumentation specific to ::Curl::Easy
+    module CurlEasy
+      # Common methods
+      include SolarWindsAPM::Inst::CurlUtility
+
+      def self.included(klass)
+        SolarWindsAPM::Util.method_alias(klass, :http, ::Curl::Easy)
+        SolarWindsAPM::Util.method_alias(klass, :perform, ::Curl::Easy)
+        SolarWindsAPM::Util.method_alias(klass, :http_put, ::Curl::Easy)
+        SolarWindsAPM::Util.method_alias(klass, :http_post, ::Curl::Easy)
+      end
+
+      ##
+      # http_post_with_sw_apm
+      #
+      # ::Curl::Easy.new.http_post wrapper
+      #
+      def http_post_with_sw_apm(*args, &block)
+        # If we're not tracing, just do a fast return.
+        if !SolarWindsAPM.tracing? || SolarWindsAPM.tracing_layer?(:curb)
+          add_tracecontext_headers(self.headers)
+          return http_post_without_sw_apm(*args)
+        end
+
+        kvs = {}
+        kvs[:HTTPMethod] = :POST
+
+        trace_curb_method(kvs, :http_post_without_sw_apm, args, &block)
+      end
+
+      ##
+      # http_put_with_sw_apm
+      #
+      # ::Curl::Easy.new.http_put wrapper
+      #
+      def http_put_with_sw_apm(*args, &block)
+        # If we're not tracing, just do a fast return.
+        if !SolarWindsAPM.tracing? || SolarWindsAPM.tracing_layer?(:curb)
+          add_tracecontext_headers(self.headers)
+          return http_put_without_sw_apm(data)
+        end
+
+        kvs = {}
+        kvs[:HTTPMethod] = :PUT
+
+        trace_curb_method(kvs, :http_put_without_sw_apm, args, &block)
+      end
+
+      ##
+      # perform_with_sw_apm
+      #
+      # ::Curl::Easy.new.perform wrapper
+      #
+      def perform_with_sw_apm(&block)
+        # If we're not tracing, just do a fast return.
+        # excluding curb layer: because the curb C code for easy.http calls perform,
+        # we have to make sure we don't log again
+        if !SolarWindsAPM.tracing? || SolarWindsAPM.tracing_layer?(:curb)
+          add_tracecontext_headers(self.headers)
+          return perform_without_sw_apm(&block)
+        end
+
+        kvs = {}
+        # This perform gets called from two places, ::Curl::Easy.new.perform
+        # and Curl::Easy.new.http_head. In the case of http_head we detect the
+        # HTTP verb via get info.
+        if self.getinfo(self.sym2curl(:nobody))
+          kvs[:HTTPMethod] = :HEAD
+        else
+          kvs[:HTTPMethod] = :GET
+        end
+
+        trace_curb_method(kvs, :perform_without_sw_apm, nil, &block)
+      end
+
+      ##
+      # http_with_sw_apm
+      #
+      # ::Curl::Easy.new.http wrapper
+      #
+      def http_with_sw_apm(verb, &block)
+        unless SolarWindsAPM.tracing?
+          add_tracecontext_headers(self.headers)
+          # If we're not tracing, just do a fast return.
+          return http_without_sw_apm(verb)
+        end
+
+        kvs = {}
+        kvs[:HTTPMethod] = verb
+
+        trace_curb_method(kvs, :http_without_sw_apm, [verb], &block)
+      end
+    end
+
+    ##
+    # CurlMultiCM
+    #
+    # This module contains the class method wrappers for the CurlMulti class.
+    # This module should be _extended_ by CurlMulti.
+    #
+    module CurlMultiCM
+      include SolarWindsAPM::Inst::CurlUtility
+
+      def self.extended(klass)
+        SolarWindsAPM::Util.class_method_alias(klass, :http, ::Curl::Multi)
+      end
+
+      ##
+      # http_with_sw_apm
+      #
+      # ::Curl::Multi.new.http wrapper
+      #
+      def http_with_sw_apm(urls_with_config, multi_options={}, &block)
+        # If we're not tracing, just do a fast return.
+        unless SolarWindsAPM.tracing?
+          urls_with_config.each do |conf|
+            conf[:headers] ||= {}
+            add_tracecontext_headers(conf[:headers])
+          end
+          return http_without_sw_apm(urls_with_config, multi_options, &block)
+        end
+
+        begin
+          kvs = {}
+          kvs[:Backtrace] = SolarWindsAPM::API.backtrace if SolarWindsAPM::Config[:curb][:collect_backtraces]
+
+          SolarWindsAPM::API.log_entry(:curb_multi, kvs)
+          context = SolarWindsAPM::Context.toString
+
+          traces = []
+          urls_with_config.each do |conf|
+            conf[:headers] ||= {}
+            add_tracecontext_headers(conf[:headers])
+          end
+          # The core curb call
+          http_without_sw_apm(urls_with_config, multi_options)
+        rescue => e
+          SolarWindsAPM::API.log_exception(:curb_multi, e)
+          raise e
+        ensure
+          SolarWindsAPM::API.log_exit(:curb_multi)
+        end
+      end
+    end
+
+    ##
+    # CurlMultiIM
+    #
+    # This module contains the instance method wrappers for the CurlMulti class.
+    # This module should be _included_ into CurlMulti.
+    #
+    module CurlMultiIM
+      include SolarWindsAPM::Inst::CurlUtility
+
+      def self.included(klass)
+        SolarWindsAPM::Util.method_alias(klass, :perform, ::Curl::Multi)
+      end
+
+      ##
+      # perform_with_sw_apm
+      #
+      # ::Curl::Multi.new.perform wrapper
+      #
+      # the reason we instrument this method is because it can be called directly,
+      # therefore we exclude calls that already have a curb layer assigned
+      # Be aware: this method is also called from the c-implementation
+      #
+      def perform_with_sw_apm(&block)
+        self.requests.each do |request|
+          request = request[1] if request.is_a?(Array)
+          add_tracecontext_headers(request.headers)
+        end
+        # If we're not tracing or we're already tracing curb, just do a fast return.
+        if !SolarWindsAPM.tracing? || [:curb, :curb_multi].include?(SolarWindsAPM.layer)
+          return perform_without_sw_apm(&block)
+        end
+
+        begin
+          kvs = {}
+          kvs[:Backtrace] = SolarWindsAPM::API.backtrace if SolarWindsAPM::Config[:curb][:collect_backtraces]
+
+          SolarWindsAPM::API.log_entry(:curb_multi, kvs)
+
+          perform_without_sw_apm(&block)
+        rescue => e
+          SolarWindsAPM::API.log_exception(:curb_multi, e)
+          raise e
+        ensure
+          SolarWindsAPM::API.log_exit(:curb_multi)
+        end
+      end
+    end
+  end
+end
+
+if SolarWindsAPM::Config[:curb][:enabled] && defined?(::Curl)
+  SolarWindsAPM.logger.info '[solarwinds_apm/loading] Instrumenting curb' if SolarWindsAPM::Config[:verbose]
+  SolarWindsAPM::Util.send_include(::Curl::Easy, SolarWindsAPM::Inst::CurlEasy)
+  SolarWindsAPM::Util.send_extend(::Curl::Multi, SolarWindsAPM::Inst::CurlMultiCM)
+  SolarWindsAPM::Util.send_include(::Curl::Multi, SolarWindsAPM::Inst::CurlMultiIM)
+end

data/lib/solarwinds_apm/inst/dalli.rb

@@ -0,0 +1,89 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module SolarWindsAPM
+  module Inst
+    module Dalli
+      include SolarWindsAPM::API::Memcache
+
+      def self.included(cls)
+        cls.class_eval do
+          SolarWindsAPM.logger.info '[solarwinds_apm/loading] Instrumenting memcache (dalli)' if SolarWindsAPM::Config[:verbose]
+          if ::Dalli::Client.private_method_defined? :perform
+            alias perform_without_sw_apm perform
+            alias perform perform_with_sw_apm
+          else
+            SolarWindsAPM.logger.warn '[solarwinds_apm/loading] Couldn\'t properly instrument Memcache (Dalli).  Partial traces may occur.'
+          end
+
+          if ::Dalli::Client.method_defined? :get_multi
+            alias get_multi_without_sw_apm get_multi
+            alias get_multi get_multi_with_sw_apm
+          end
+        end
+      end
+
+      def perform_with_sw_apm(*all_args, &blk)
+        op, key, *args = *all_args
+
+        report_kvs = {}
+        report_kvs[:KVOp] = op
+        report_kvs[:KVKey] = key
+
+        servers = @servers || @normalized_servers # name change since Dall 3.2.0
+        if servers.is_a?(Array) && !servers.empty?
+          report_kvs[:RemoteHost] = servers.join(", ")
+        end
+
+        if SolarWindsAPM.tracing? && !SolarWindsAPM.tracing_layer_op?(:get_multi)
+          SolarWindsAPM::SDK.trace(:memcache, kvs: report_kvs) do
+            result = perform_without_sw_apm(*all_args, &blk)
+
+            # Clear the hash for a potential info event
+            report_kvs.clear
+            report_kvs[:KVHit] = memcache_hit?(result) if op == :get && key.class == String
+            report_kvs[:Backtrace] = SolarWindsAPM::API.backtrace if SolarWindsAPM::Config[:dalli][:collect_backtraces]
+
+            result
+          end
+        else
+          perform_without_sw_apm(*all_args, &blk)
+        end
+      end
+
+      def get_multi_with_sw_apm(*keys)
+        return get_multi_without_sw_apm(*keys) unless SolarWindsAPM.tracing?
+
+        info_kvs = {}
+
+        begin
+          info_kvs[:KVKeyCount] = keys.flatten.length
+          info_kvs[:KVKeyCount] = (info_kvs[:KVKeyCount] - 1) if keys.last.is_a?(Hash) || keys.last.nil?
+
+          servers = @servers || @normalized_servers # name change since Dalli 3.2.1
+          if servers.is_a?(Array) && !servers.empty?
+            info_kvs[:RemoteHost] = servers.join(", ")
+          end
+        rescue => e
+          SolarWindsAPM.logger.debug "[solarwinds_apm/debug] #{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}" if SolarWindsAPM::Config[:verbose]
+        end
+
+        info_kvs[:KVOp] = :get_multi
+        info_kvs[:Backtrace] = SolarWindsAPM::API.backtrace if SolarWindsAPM::Config[:dalli][:collect_backtraces]
+        SolarWindsAPM::SDK.trace(:memcache, kvs: info_kvs, protect_op: :get_multi) do
+          values = get_multi_without_sw_apm(*keys)
+
+          info_kvs[:KVHitCount] = values.length
+
+          values
+        end
+      end
+    end
+  end
+end
+
+if defined?(Dalli) && SolarWindsAPM::Config[:dalli][:enabled]
+  ::Dalli::Client.module_eval do
+    include SolarWindsAPM::Inst::Dalli
+  end
+end