tingyun_rpm 1.2.0 → 1.3.0

data/lib/ting_yun/agent/transaction/transaction_timings.rb

@@ -12,7 +12,7 @@ module TingYun
         @queue_time_in_seconds = clamp_to_positive(queue_time_in_seconds.to_f)
         @start_time_in_seconds = clamp_to_positive(start_time_in_seconds.to_f)
 
-        @timings = TingYun::Agent::TransactionTimings::Timings.new(0.0,0.0,0.0,0.0,0.0)
+        @timings = TingYun::Agent::TransactionTimings::Timings.new(0.0, 0.0, 0.0, 0.0, 0.0)
       end
 
 
@@ -27,7 +27,6 @@ module TingYun
                      :mon_duration, :mon_duration=
 
 
-
       def start_time_as_time
         Time.at(@start_time_in_seconds)
       end

data/lib/ting_yun/agent/transaction.rb

@@ -26,13 +26,16 @@ module TingYun
 
       SUBTRANSACTION_PREFIX = 'Nested/'.freeze
       CONTROLLER_PREFIX = 'WebAction/'.freeze
+      BACKGROUND_PREFIX = 'BackgroundAction/'.freeze
       RAKE_TRANSACTION_PREFIX     = 'BackgroundAction/Rake'.freeze
       TASK_PREFIX = 'OtherTransaction/Background/'.freeze
       RACK_PREFIX = 'Rack/'.freeze
-      SINATRA_PREFIX = 'Sinatra/'.freeze
+      SINATRA_PREFIX = 'WebAction/Sinatra/'.freeze
       MIDDLEWARE_PREFIX = 'Middleware/Rack/'.freeze
-      GRAPE_PREFIX = 'Grape/'.freeze
-      RAKE_PREFIX = 'Rake'.freeze
+      GRAPE_PREFIX = 'WebAction/Grape/'.freeze
+      RAKE_PREFIX = 'WebAction/Rake'.freeze
+      CABLE_PREFIX = 'WebAction/ActionCable'.freeze
+
 
       EMPTY_SUMMARY_METRICS = [].freeze
       MIDDLEWARE_SUMMARY_METRICS = ['Middleware/all'.freeze].freeze
@@ -57,7 +60,8 @@ module TingYun
                   :guid,
                   :category,
                   :default_name,
-                  :start_time
+                  :start_time,
+                  :base_quantile_hash
 
 
 
@@ -75,6 +79,7 @@ module TingYun
         @guid = client_transaction_id || generate_guid
         @frame_stack = []
         @frozen_name = nil
+        @base_quantile_hash = {}
         @default_name = TingYun::Helper.correctly_encoded(options[:transaction_name])
 
         if request = options[:request]
@@ -108,7 +113,7 @@ module TingYun
 
 
 
-      def stop(state, end_time, outermost_frame)
+      def stop(state, end_time, outermost_frame, summary_metrics = [])
 
         freeze_name_and_execute
 
@@ -125,7 +130,7 @@ module TingYun
         else
           summary_metrics_with_exclusive_time = EMPTY_SUMMARY_METRICS
         end
-
+        summary_metrics_with_exclusive_time = summary_metrics unless summary_metrics.empty?
 
         TingYun::Agent::MethodTracerHelpers.trace_execution_scoped_footer(
             state,
@@ -149,12 +154,13 @@ module TingYun
 
         TingYun::Agent.instance.sql_sampler.on_finishing_transaction(state, @frozen_name)
 
-        record_summary_metrics(outermost_node_name, end_time)
+        record_summary_metrics(state, outermost_node_name, end_time)
         @apdex.record_apdex(@frozen_name, end_time, @exceptions.had_error?)
         @exceptions.record_exceptions(@attributes)
 
 
         TingYun::Agent.instance.stats_engine.merge_transaction_metrics!(@metrics, best_name)
+        TingYun::Agent.instance.stats_engine.record_base_quantile(@base_quantile_hash) if @exceptions.exceptions.empty?
       end
 
     end

data/lib/ting_yun/configuration/default_source.rb

@@ -46,6 +46,8 @@ module TingYun
                   :rails3
                 when 4
                   :rails4
+                when 5
+                  :rails5
                 else
                   ::TingYun::Agent.logger.error "Detected unsupported Rails version #{Rails::VERSION::STRING}"
               end
@@ -85,13 +87,6 @@ module TingYun
         Proc.new { ::TingYun::Frameworks.framework.local_env.discovered_dispatcher }
       end
 
-
-      def self.audit_log_path
-        Proc.new {
-          File.join(TingYun::Agent.config[:log_file_path], 'newrelic_audit.log')
-        }
-      end
-
       # On Rubies with string encodings support (1.9.x+), default to always
       # normalize encodings since it's safest and fast. Without that support
       # the conversions are too expensive, so only enable if overridden to.
@@ -348,6 +343,27 @@ module TingYun
             :allowed_from_server => false,
             :description => 'log  filename.'
         },
+        :agent_log_file_size => {
+            :default => 500,
+            :public => true,
+            :type => Fixnum,
+            :allowed_from_server => false,
+            :description => "Create a new logfile once it reaches this value. and this value's unit is MB."
+        },
+        :agent_log_file_number => {
+            :default => 10,
+            :public => true,
+            :type => Fixnum,
+            :allowed_from_server => false,
+            :description => "The remaining number of log file, delete the earliest when more than this value."
+        },
+        :agent_log_file_check_days => {
+            :default => 7,
+            :public => true,
+            :type => Fixnum,
+            :allowed_from_server => false,
+            :description => "Check for create new logfile when reach days of this value."
+        },
         :config_search_paths => {
             :default => DefaultSource.config_search_paths,
             :public => false,
@@ -645,6 +661,27 @@ module TingYun
             :type => Boolean,
             :allowed_from_server => true,
             :description => 'Enable or disable the thrift cross application feature'
+        },
+        :restart_thread_in_children => {
+            :default => true,
+            :public => false,
+            :type => Boolean,
+            :allowed_from_server => false,
+            :description => 'Controls whether to check on running a transaction whether to respawn the harvest thread.'
+        },
+        :'nbs.quantile' => {
+            :default => nil,
+            :public => true,
+            :type => String,
+            :allowed_from_server => true,
+            :description => 'Quantile'
+        },
+        :'nbs.mq.conume' => {
+            :default => false,
+            :public => true,
+            :type => Boolean,
+            :allowed_from_server => true,
+            :description => 'Enable or disable the  mq feature'
         }
     }.freeze
   end

data/lib/ting_yun/configuration/yaml_source.rb

@@ -2,6 +2,7 @@
 require 'ting_yun/configuration/dotted_hash'
 require 'ting_yun/support/language_support'
 require 'erb'
+require 'yaml'
 
 module TingYun
   module Configuration

data/lib/ting_yun/frameworks/instrumentation.rb

@@ -32,7 +32,12 @@ module TingYun
       def load_instrumentation_files(pattern)
         Dir.glob(pattern) do |file|
           begin
-            require file.to_s
+            if file.to_s.include?('instrumentation/kafka.rb')
+              # (**options) will report syntax error when ruby version under 2.0.0
+              require file.to_s if (defined? RUBY_VERSION) && (TingYun::Support::VersionNumber.new(RUBY_VERSION) >= TingYun::Support::VersionNumber.new('2.0.0'.freeze))
+            else
+              require file.to_s
+            end
           rescue LoadError => e
             TingYun::Agent.logger.warn "Error loading instrumentation file '#{file}':", e
           end

data/lib/ting_yun/frameworks/rails5.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+
+require 'ting_yun/frameworks/rails4'
+
+module TingYun
+  module Frameworks
+    class Rails5 < TingYun::Frameworks::Rails4
+    end
+  end
+end

data/lib/ting_yun/frameworks.rb

@@ -2,7 +2,7 @@
 # This file is distributed under Ting Yun's license terms.
 require 'ting_yun/frameworks/instance_methods'
 require 'ting_yun/frameworks/class_methods'
-
+require 'yaml'
 
 module TingYun
   module Frameworks

data/lib/ting_yun/http/http_client_request.rb

@@ -0,0 +1,39 @@
+require 'ting_yun/http/generic_request'
+module TingYun
+  module Http
+    class HttpClientRequest < GenericRequest
+      attr_reader :method, :header
+
+      def initialize(proxy, *args, &block)
+        @method, @uri, @query, @body, @header = args
+        @proxy = proxy
+        @block = block
+      end
+
+      def type
+        'HTTPClient'
+      end
+
+      def from
+        "http_client%2Fhttp"
+      end
+
+      def [](key)
+        @header[key]
+      end
+
+      def []=(key, value)
+        @header[key] = value
+      end
+
+      def uri
+        return @uri if @uri.scheme && @uri.host && @uri.port
+        URI("#{@proxy.scheme.downcase}://#{@proxy.host}:#{@proxy.port}#{@uri}")
+      end
+
+      def args
+        return @method, @uri, @query, @body, @header
+      end
+    end
+  end
+end

data/lib/ting_yun/http/net_http_request.rb

@@ -11,6 +11,10 @@ module TingYun
         'Net::HTTP'
       end
 
+      def from
+        "net%2Fhttp"
+      end
+
       def host
         if hostname = self['host']
           hostname.split(':').first

data/lib/ting_yun/instrumentation/active_record.rb

@@ -2,10 +2,11 @@
 require 'ting_yun/agent/transaction/transaction_state'
 require 'ting_yun/instrumentation/support/active_record_helper'
 require 'ting_yun/support/helper'
-require 'ting_yun/agent/method_tracer'
+require 'ting_yun/agent/method_tracer_helpers'
 require 'ting_yun/agent/collector/transaction_sampler'
 require 'ting_yun/agent/collector/sql_sampler'
 require 'ting_yun/agent/database'
+require 'ting_yun/instrumentation/support/sinatra_helper'
 
 module TingYun
   module Instrumentation
@@ -43,14 +44,14 @@ module TingYun
 
         state = TingYun::Agent::TransactionState.tl_get
         sql, name, _ = args
-        metrics = ::TingYun::Instrumentation::Support::ActiveRecordHelper.metrics_for(
+        klass_name, *metrics = ::TingYun::Instrumentation::Support::ActiveRecordHelper.metrics_for(
             TingYun::Helper.correctly_encoded(name),
             TingYun::Helper.correctly_encoded(sql),
-            @config && @config[:adapter])
+            @config)
 
         scoped_metric = metrics.first
 
-        TingYun::Agent::MethodTracer.trace_execution_scoped(metrics) do
+        TingYun::Agent::MethodTracerHelpers.trace_execution_scoped(metrics, {}, nil, klass_name) do
           t0 = Time.now
           begin
             log_without_tingyun_instrumentation(*args, &block)
@@ -72,10 +73,15 @@ end
 TingYun::Support::LibraryDetection.defer do
   named :active_record
 
+  depends_on do
+    !::TingYun::Agent.config[:disable_active_record]
+  end
+
   depends_on do
     defined?(::ActiveRecord) && defined?(::ActiveRecord::Base) &&
         (!defined?(::ActiveRecord::VERSION) ||
-            ::ActiveRecord::VERSION::MAJOR.to_i <= 3)
+            ::ActiveRecord::VERSION::MAJOR.to_i <= 3 ||
+            (defined?(::Sinatra) && defined?(::Sinatra::Base) && TingYun::Instrumentation::Support::SinatraHelper.version_supported?))
   end
 
   executes do

data/lib/ting_yun/instrumentation/bunny.rb

@@ -0,0 +1,142 @@
+TingYun::Support::LibraryDetection.defer do
+  named :bunny
+
+  depends_on do
+    defined?(::Bunny::VERSION) && false
+  end
+
+
+  executes do
+    TingYun::Agent.logger.info 'Installing bunny(for rabbitmq) Instrumentation'
+    require 'ting_yun/support/helper'
+    require 'ting_yun/instrumentation/support/external_helper'
+  end
+
+  executes do
+    ::Bunny::Exchange.class_eval do
+
+      if public_method_defined? :publish
+        include TingYun::Instrumentation::Support::ExternalHelper
+        def publish_with_tingyun(payload, opts = {})
+          begin
+            state = TingYun::Agent::TransactionState.tl_get
+            return publish_without_tingyun(payload, opts) unless state.execution_traced?
+            queue_name = opts[:routing_key]
+            opts[:headers] = {} unless opts[:headers]
+            opts[:headers][:TingyunID] = create_tingyun_id("mq")
+            metric_name = "Message RabbitMQ/#{@channel.connection.host}:#{@channel.connection.port}%2F"
+            if name.empty?
+              metric_name << "Queue%2F#{queue_name}/Produce"
+            else
+              metric_name << "Exchange%2F#{name}/Produce"
+            end
+
+            summary_metrics = TingYun::Agent::Datastore::MetricHelper.metrics_for_message('RabbitMQ', "#{@channel.connection.host}:#{@channel.connection.port}", 'Produce')
+            TingYun::Agent::Transaction.wrap(state, metric_name , :RabbitMq, {}, summary_metrics)  do
+              TingYun::Agent.record_metric("#{metric_name}%2FByte",payload.bytesize) if payload
+              publish_without_tingyun(payload, opts)
+            end
+          rescue => e
+            TingYun::Agent.logger.error("Failed to Bunny publish_with_tingyun : ", e)
+            publish_without_tingyun(payload, opts)
+          end
+        end
+
+
+
+
+        alias_method :publish_without_tingyun, :publish
+        alias_method :publish, :publish_with_tingyun
+      end
+
+    end
+
+    ::Bunny::Consumer.class_eval do
+
+      if public_method_defined?(:call) && TingYun::Agent.config[:'nbs.mq.conume']
+
+        def call_with_tingyun(*args)
+          begin
+            headers = args[1]&&args[1][:headers].clone
+            tingyun_id_secret = headers["TingyunID"]
+            state = TingYun::Agent::TransactionState.tl_get
+            metric_name = "#{@channel.connection.host}:#{@channel.connection.port}%2FQueue%2F#{queue_name}/Consume"
+            summary_metrics = TingYun::Agent::Datastore::MetricHelper.metrics_for_message('RabbitMQ', "#{@channel.connection.host}:#{@channel.connection.port}", 'Consume')
+            TingYun::Agent::Transaction.start(state,:message, { :transaction_name => "WebAction/RabbitMQ/Queue%2F#{queue_name}/Consume"})
+            state.save_referring_transaction_info(tingyun_id_secret.split(';')) if cross_app_enabled?(tingyun_id_secret)
+            TingYun::Agent::Transaction.wrap(state, "Message RabbitMQ/#{metric_name}" , :RabbitMq, {}, summary_metrics)  do
+              TingYun::Agent.record_metric("Message RabbitMQ/#{metric_name}%2FByte",args[2].bytesize) if args[2]
+              TingYun::Agent.record_metric("Message RabbitMQ/#{metric_name}%2FWait", TingYun::Helper.time_to_millis(Time.now)-state.externel_time.to_i) rescue nil
+              if state.current_transaction
+                state.add_custom_params("message.byte",args[2].bytesize)
+                state.add_custom_params("message.wait",TingYun::Helper.time_to_millis(Time.now)-state.externel_time.to_i)
+                state.add_custom_params("message.routingkey",queue_name)
+                headers.delete("TingyunID")
+                state.merge_request_parameters(headers)
+              end
+              call_without_tingyun(*args)
+              state.current_transaction.attributes.add_agent_attribute(:entryTrace, build_payload(state)) if state.same_account?
+            end
+          rescue => e
+            TingYun::Agent.logger.error("Failed to Bunny call_with_tingyun : ", e)
+            call_without_tingyun(*args)
+          ensure
+            TingYun::Agent::Transaction.stop(state, Time.now, summary_metrics)
+          end
+
+        end
+        alias_method :call_without_tingyun, :call
+        alias_method :call, :call_with_tingyun
+
+      end
+
+      def cross_app_enabled?(tingyun_id_secret)
+        tingyun_id_secret && ::TingYun::Agent.config[:tingyunIdSecret]
+      end
+
+      def build_payload(state)
+        timings = state.timings
+        payload = {
+            :applicationId => TingYun::Agent.config[:tingyunIdSecret].split('|')[1],
+            :transactionId => state.client_transaction_id,
+            :externalId => state.extenel_req_id,
+            :time => {
+                :duration => timings.app_time_in_millis,
+                :qu => timings.queue_time_in_millis,
+                :db => timings.sql_duration,
+                :ex => timings.external_duration,
+                :rds => timings.rds_duration,
+                :mc => timings.mc_duration,
+                :mon => timings.mon_duration,
+                :code => timings.app_execute_duration
+            }
+        }
+        payload
+      end
+    end
+
+    ::Bunny::Channel.class_eval do
+      if public_method_defined?(:basic_get)&& TingYun::Agent.config[:'nbs.mq.conume']
+        def basic_get_with_tingyun(*args)
+          begin
+            state = TingYun::Agent::TransactionState.tl_get
+            metric_name = "#{@connection.host}:#{@connection.port}%2FQueue%2F#{args[0]}/Consume"
+            summary_metrics = TingYun::Agent::Datastore::MetricHelper.metrics_for_message('RabbitMQ', "#{connection.host}:#{connection.port}", 'Consume')
+            TingYun::Agent::Transaction.wrap(state, "Message RabbitMQ/#{metric_name}" , :RabbitMq, {}, summary_metrics)  do
+              basic_get_without_tingyun(*args)
+            end
+          rescue =>e
+            TingYun::Agent.logger.error("Failed to Bunny basic_get_with_tingyun : ", e)
+            basic_get_without_tingyun(*args)
+          ensure
+            TingYun::Agent::Transaction.stop(state, Time.now, summary_metrics)
+          end
+        end
+
+        alias_method :basic_get_without_tingyun, :basic_get
+        alias_method :basic_get, :basic_get_with_tingyun
+      end
+    end
+  end
+
+end

data/lib/ting_yun/instrumentation/data_mapper.rb

@@ -0,0 +1,167 @@
+# encoding: utf-8
+require 'ting_yun/agent/transaction/transaction_state'
+require 'ting_yun/instrumentation/support/active_record_helper'
+require 'ting_yun/agent/method_tracer_helpers'
+
+module TingYun::Instrumentation::DataMapper
+
+  MIN_SUPPORT_VERSION = '1.1.0.rc1'.freeze
+
+  def self.supported_version?
+    ::TingYun::Support::VersionNumber.new(::DataMapper::VERSION) >= ::TingYun::Support::VersionNumber.new(MIN_SUPPORT_VERSION)
+  end
+
+  def self.support_data_mapper?
+    defined?(::DataMapper) &&
+        ((defined?(::DataMapper::Adapters) && defined?(::DataMapper::Adapters::DataObjectsAdapter)) ||
+         (defined?(::DataMapper::Aggregates) && defined?(::DataMapper::Aggregates::DataObjectsAdapter))) &&
+        supported_version?
+  end
+
+end
+
+TingYun::Support::LibraryDetection.defer do
+  named :data_mapper
+
+  depends_on do
+    !::TingYun::Agent.config[:disable_data_mapper]
+  end
+
+  depends_on do
+    begin
+      require 'dm-do-adapter'
+      TingYun::Instrumentation::DataMapper.support_data_mapper?
+    rescue LoadError
+      false
+    end
+  end
+
+  executes do
+    ::TingYun::Agent.logger.info 'Installing DataMapper instrumentation'
+  end
+
+  executes do
+
+    if defined?(::DataMapper::Adapters) && defined?(::DataMapper::Adapters::DataObjectsAdapter)
+      ::DataMapper::Adapters::DataObjectsAdapter.class_eval do
+
+        def create(resources)
+          name = self.name
+
+          resources.each do |resource|
+            model      = resource.model
+            state = TingYun::Agent::TransactionState.tl_get
+            *params = get_metrics_params(:create, model)
+            klass_name, *metrics = ::TingYun::Instrumentation::Support::ActiveRecordHelper.metrics_for_data_mapper(*params)
+
+            TingYun::Agent::MethodTracerHelpers.trace_execution_scoped(metrics, {}, nil, klass_name) do
+              t0 = Time.now
+              begin
+                serial     = model.serial(name)
+                attributes = resource.dirty_attributes
+
+                properties  = []
+                bind_values = []
+
+                # make the order of the properties consistent
+                model.properties(name).each do |property|
+                  next unless attributes.key?(property)
+
+                  bind_value = attributes[property]
+
+                  # skip insering NULL for columns that are serial or without a default
+                  next if bind_value.nil? && (property.serial? || !property.default?)
+
+                  # if serial is being set explicitly, do not set it again
+                  if property.equal?(serial)
+                    serial = nil
+                  end
+
+                  properties  << property
+                  bind_values << bind_value
+                end
+
+                statement = insert_statement(model, properties, serial)
+
+                result = with_connection do |connection|
+                  connection.create_command(statement).execute_non_query(*bind_values)
+                end
+
+                if result.affected_rows == 1 && serial
+                  serial.set!(resource, result.insert_id)
+                end
+              ensure
+                elapsed_time = (Time.now - t0).to_f
+                state.timings.sql_duration = state.timings.sql_duration  + elapsed_time * 1000
+              end
+            end
+          end
+        end
+
+        [:read, :update, :delete, :select, :execute].each do |method|
+          next unless public_method_defined? method
+          alias_method "#{method}_without_tingyun_trace".to_sym, method.to_sym
+
+          define_method method do |*args, &block|
+            state = TingYun::Agent::TransactionState.tl_get
+            *params = get_metrics_params(method, *args, &block)
+            klass_name, *metrics = ::TingYun::Instrumentation::Support::ActiveRecordHelper.metrics_for_data_mapper(*params)
+
+            TingYun::Agent::MethodTracerHelpers.trace_execution_scoped(metrics, {}, nil, klass_name) do
+              t0 = Time.now
+              begin
+                send "#{method}_without_tingyun_trace", *args, &block
+              ensure
+                elapsed_time = (Time.now - t0).to_f
+                state.timings.sql_duration = state.timings.sql_duration  + elapsed_time * 1000
+              end
+            end
+          end
+        end
+
+        def get_metrics_params(method, *args, &block)
+          case method
+            when :read
+              query = args[0]
+              return TingYun::Helper.correctly_encoded('SELECT'), nil, self.normalized_uri, DataMapper::Inflector.classify(query.model.storage_name(name))
+            when :update
+              collection = args[1]
+              return TingYun::Helper.correctly_encoded('UPDATE'), nil, self.normalized_uri, DataMapper::Inflector.classify(collection.query.model.storage_name(name))
+            when :delete
+              collection = args[0]
+              return TingYun::Helper.correctly_encoded('DELETE'), nil, self.normalized_uri, DataMapper::Inflector.classify(collection.query.model.storage_name(name))
+            when :create
+              model = args[0]
+              return TingYun::Helper.correctly_encoded('INSERT'), nil, self.normalized_uri, DataMapper::Inflector.classify(model.storage_name(name))
+            when :select, :execute
+              sql = args[0]
+              return nil, sql, self.normalized_uri
+          end
+        end
+      end
+    end
+
+    if defined?(::DataMapper::Aggregates) && defined?(::DataMapper::Aggregates::DataObjectsAdapter)
+      ::DataMapper::Aggregates::DataObjectsAdapter.class_eval do
+
+        alias_method :aggregate_without_tingyun_trace, :aggregate
+
+        def aggregate(*args, &block)
+          state = TingYun::Agent::TransactionState.tl_get
+          *params = get_metrics_params(:read, *args, &block)
+          klass_name, *metrics = ::TingYun::Instrumentation::Support::ActiveRecordHelper.metrics_for_data_mapper(*params)
+
+          TingYun::Agent::MethodTracerHelpers.trace_execution_scoped(metrics, {}, nil, klass_name) do
+            t0 = Time.now
+            begin
+              aggregate_without_tingyun_trace(*args, &block)
+            ensure
+              elapsed_time = (Time.now - t0).to_f
+              state.timings.sql_duration = state.timings.sql_duration  + elapsed_time * 1000
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ting_yun/instrumentation/grape.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+require 'ting_yun/agent/transaction'
+require 'ting_yun/agent/transaction/transaction_state'
+
+TingYun::Support::LibraryDetection.defer do
+  named :grape
+
+  depends_on do
+    defined?(::Grape) && defined?(::Grape::Endpoint)
+  end
+
+  executes do
+    TingYun::Agent.logger.info 'Installing grape instrumentation'
+  end
+
+
+  executes do
+    ::Grape::Endpoint.class_eval do
+      def run_with_tingyun(*args)
+        begin
+          name = ["Grape",
+                  self.options[:method].first,
+                  self.options[:for].to_s,
+                  self.namespace.sub(%r{\A/}, ''), # removing leading slashes
+                  self.options[:path].first.sub(%r{\A/}, ''),
+          ].compact.select{ |n| n.to_s unless n.to_s.empty? }.join("/")
+          TingYun::Agent::Transaction.set_default_transaction_name(name, :controller)
+          run_without_tingyun(*args)
+        rescue => e
+          TingYun::Agent.logger.info("Error getting Grape Endpoint Name. Error: #{e.message}. Options: #{self.options.inspect}")
+        end
+
+      end
+      alias run_without_tingyun run
+      alias run run_with_tingyun
+    end
+
+  end
+end