newrelic_rpm 9.7.0 → 9.16.1

data/lib/new_relic/agent/serverless_handler.rb

@@ -0,0 +1,400 @@
+# 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 'json'
+require 'new_relic/base64'
+require 'uri'
+
+require_relative 'serverless_handler_event_sources'
+
+module NewRelic
+  module Agent
+    class ServerlessHandler
+      AGENT_ATTRIBUTE_DESTINATIONS = NewRelic::Agent::AttributeFilter::DST_TRANSACTION_TRACER |
+        NewRelic::Agent::AttributeFilter::DST_TRANSACTION_EVENTS
+      EXECUTION_ENVIRONMENT = "AWS_Lambda_ruby#{RUBY_VERSION.rpartition('.').first}".freeze
+      LAMBDA_MARKER = 'NR_LAMBDA_MONITORING'
+      LAMBDA_ENVIRONMENT_VARIABLE = 'AWS_LAMBDA_FUNCTION_NAME'
+      METHOD_BLOCKLIST = %i[agent_command_results connect get_agent_commands preconnect profile_data
+        shutdown].freeze
+      NAMED_PIPE = '/tmp/newrelic-telemetry'
+      SUPPORTABILITY_METRIC = 'Supportability/AWSLambda/HandlerInvocation'
+      FUNCTION_NAME = 'lambda_function'
+      PAYLOAD_VERSION = ENV.fetch('NEW_RELIC_SERVERLESS_PAYLOAD_VERSION', 2)
+      DIGIT = /\d/
+      EVENT_SOURCES = NewRelic::Agent::ServerlessHandlerEventSources.to_hash
+
+      def self.env_var_set?
+        ENV.key?(LAMBDA_ENVIRONMENT_VARIABLE)
+      end
+
+      def initialize
+        @event = nil
+        @context = nil
+        @payloads = {}
+      end
+
+      def invoke_lambda_function_with_new_relic(event:, context:, method_name:, namespace: nil)
+        NewRelic::Agent.increment_metric(SUPPORTABILITY_METRIC)
+
+        @event, @context = event, context
+
+        NewRelic::Agent::Tracer.in_transaction(category: category, name: function_name) do
+          prep_transaction
+
+          process_response(NewRelic::LanguageSupport.constantize(namespace)
+            .send(method_name, event: event, context: context))
+        end
+      ensure
+        harvest!
+        write_output
+        reset!
+      end
+
+      def store_payload(method, payload)
+        return if METHOD_BLOCKLIST.include?(method)
+
+        @payloads[method] = payload
+      end
+
+      def metric_data(stats_hash)
+        payload = [nil,
+          stats_hash.started_at,
+          (stats_hash.harvested_at || Process.clock_gettime(Process::CLOCK_REALTIME)),
+          []]
+        stats_hash.each do |metric_spec, stats|
+          next if stats.is_reset?
+
+          hash = {name: metric_spec.name}
+          hash[:scope] = metric_spec.scope unless metric_spec.scope.empty?
+
+          payload.last.push([hash, [
+            stats.call_count,
+            stats.total_call_time,
+            stats.total_exclusive_time,
+            stats.min_call_time,
+            stats.max_call_time,
+            stats.sum_of_squares
+          ]])
+        end
+
+        return if payload.last.empty?
+
+        store_payload(:metric_data, payload)
+      end
+
+      def error_data(errors)
+        store_payload(:error_data, [nil, errors.map(&:to_collector_array)])
+      end
+
+      private
+
+      def prep_transaction
+        process_api_gateway_info
+        process_headers
+        add_agent_attributes
+      end
+
+      def harvest!
+        NewRelic::Agent.instance.harvest_and_send_analytic_event_data
+        NewRelic::Agent.instance.harvest_and_send_custom_event_data
+        NewRelic::Agent.instance.harvest_and_send_data_types
+      end
+
+      def metadata
+        m = {arn: @context.invoked_function_arn,
+             protocol_version: NewRelic::Agent::NewRelicService::PROTOCOL_VERSION,
+             function_version: @context.function_version,
+             execution_environment: EXECUTION_ENVIRONMENT,
+             agent_version: NewRelic::VERSION::STRING}
+        if PAYLOAD_VERSION >= 2
+          m[:metadata_version] = PAYLOAD_VERSION
+          m[:agent_language] = NewRelic::LANGUAGE
+        end
+        m
+      end
+
+      def function_name
+        ENV.fetch(LAMBDA_ENVIRONMENT_VARIABLE, FUNCTION_NAME)
+      end
+
+      def category
+        @category ||=
+          @event&.dig('requestContext', 'http', 'method') || @event&.fetch('httpMethod', nil) ? :web : :other
+      end
+
+      def write_output
+        string = PAYLOAD_VERSION == 1 ? payload_v1 : payload_v2
+
+        return puts string unless use_named_pipe?
+
+        File.write(NAMED_PIPE, string)
+
+        NewRelic::Agent.logger.debug "Wrote serverless payload to #{NAMED_PIPE}\n" \
+          "BEGIN PAYLOAD>>>\n#{string}\n<<<END PAYLOAD"
+      end
+
+      def payload_v1 # New Relic serverless payload v1
+        payload_hash = {'metadata' => metadata, 'data' => @payloads}
+        json = NewRelic::Agent.agent.service.marshaller.dump(payload_hash)
+        gzipped = NewRelic::Agent::NewRelicService::Encoders::Compressed::Gzip.encode(json)
+        base64_encoded = NewRelic::Base64.strict_encode64(gzipped)
+        array = [PAYLOAD_VERSION, LAMBDA_MARKER, base64_encoded]
+        ::JSON.dump(array)
+      end
+
+      def payload_v2 # New Relic serverless payload v2
+        json = NewRelic::Agent.agent.service.marshaller.dump(@payloads)
+        gzipped = NewRelic::Agent::NewRelicService::Encoders::Compressed::Gzip.encode(json)
+        base64_encoded = NewRelic::Base64.strict_encode64(gzipped)
+        array = [PAYLOAD_VERSION, LAMBDA_MARKER, metadata, base64_encoded]
+        ::JSON.dump(array)
+      end
+
+      def determine_api_gateway_version
+        return unless @event
+
+        version = @event.fetch('version', '')
+        if version.start_with?('2.')
+          return 2
+        elsif version.start_with?('1.')
+          return 1
+        end
+
+        headers = headers_from_event
+        return unless headers
+
+        if @event.dig('requestContext', 'http', 'path') && @event.dig('requestContext', 'http', 'method')
+          2
+        elsif @event.fetch('path', nil) && @event.fetch('httpMethod', nil)
+          1
+        end
+      end
+
+      def process_api_gateway_info
+        api_v = determine_api_gateway_version
+        return unless api_v
+
+        info = api_v == 2 ? info_for_api_gateway_v2 : info_for_api_gateway_v1
+        info[:query_parameters] = @event.fetch('queryStringParameters', nil)
+
+        @http_method = info[:method]
+        @http_uri = http_uri(info)
+      end
+
+      def http_uri(info)
+        return unless info[:host] && info[:path]
+
+        url_str = "https://#{info[:host]}"
+        url_str += ":#{info[:port]}" unless info[:host].match?(':')
+        url_str += "#{info[:path]}"
+
+        if info[:query_parameters]
+          qp = info[:query_parameters].map { |k, v| "#{k}=#{v}" }.join('&')
+          url_str += "?#{qp}"
+        end
+
+        URI.parse(url_str)
+      rescue StandardError => e
+        NewRelic::Agent.logger.error "ServerlessHandler failed to parse the source HTTP URI: #{e}"
+      end
+
+      def info_for_api_gateway_v2
+        ctx = @event.fetch('requestContext', nil)
+        return {} unless ctx
+
+        {method: ctx.dig('http', 'method'),
+         path: ctx.dig('http', 'path'),
+         host: ctx.fetch('domainName', @event.dig('headers', 'Host')),
+         port: @event.dig('headers', 'X-Forwarded-Port') || 443}
+      end
+
+      def info_for_api_gateway_v1
+        headers = headers_from_event
+        {method: @event.fetch('httpMethod', nil),
+         path: @event.fetch('path', nil),
+         host: headers.fetch('Host', nil),
+         port: headers.fetch('X-Forwarded-Port', 443)}
+      end
+
+      def process_headers
+        return unless ::NewRelic::Agent.config[:'distributed_tracing.enabled']
+
+        headers = headers_from_event
+        return unless headers && !headers.empty?
+
+        dt_headers = headers.fetch(NewRelic::NEWRELIC_KEY, nil)
+        return unless dt_headers
+
+        ::NewRelic::Agent::DistributedTracing::accept_distributed_trace_headers(dt_headers, 'Other')
+      end
+
+      def headers_from_event
+        @headers ||= @event&.dig('requestContext', 'http') || @event&.dig('headers')
+      end
+
+      def use_named_pipe?
+        return @use_named_pipe if defined?(@use_named_pipe)
+
+        @use_named_pipe = File.exist?(NAMED_PIPE) && File.writable?(NAMED_PIPE)
+      end
+
+      def add_agent_attributes
+        return unless NewRelic::Agent::Tracer.current_transaction
+
+        add_agent_attribute('aws.lambda.coldStart', true) if cold?
+        add_agent_attribute('aws.lambda.arn', @context.invoked_function_arn)
+        add_agent_attribute('aws.requestId', @context.aws_request_id)
+
+        add_event_source_attributes
+        add_http_attributes if api_gateway_event?
+      end
+
+      def add_http_attributes
+        return unless category == :web
+
+        if @http_uri
+          add_agent_attribute('uri.host', @http_uri.host)
+          add_agent_attribute('uri.port', @http_uri.port)
+          if NewRelic::Agent.instance.attribute_filter.allows_key?('http.url', AttributeFilter::DST_SPAN_EVENTS)
+            add_agent_attribute('http.url', @http_uri.to_s)
+          end
+        end
+
+        if @http_method
+          add_agent_attribute('http.method', @http_method)
+          add_agent_attribute('http.request.method', @http_method)
+        end
+      end
+
+      def api_gateway_event?
+        return false unless @event
+
+        # '1.0' for API Gateway V1, '2.0' for API Gateway V2
+        return true if @event.fetch('version', '').start_with?(DIGIT)
+
+        return false unless headers_from_event
+
+        # API Gateway V1 - look for toplevel 'path' and 'httpMethod' keys if a version is unset
+        return true if @event.fetch('path', nil) && @event.fetch('httpMethod', nil)
+
+        # API Gateway V2 - look for 'requestContext/http' inner nested 'path' and 'method' keys if a version is unset
+        return true if @event.dig('requestContext', 'http', 'path') && @event.dig('requestContext', 'http', 'method')
+
+        false
+      end
+
+      def add_event_source_attributes
+        arn = event_source_arn
+        add_agent_attribute('aws.lambda.eventSource.arn', arn) if arn
+
+        info = event_source_event_info
+        return unless info
+
+        add_agent_attribute('aws.lambda.eventSource.eventType', info['name'])
+
+        info['attributes'].each do |name, elements|
+          next if elements.empty?
+
+          size = false
+          if elements.last.eql?('#size')
+            elements = elements.dup
+            elements.pop
+            size = true
+          end
+          value = @event.dig(*elements)
+          value = value.size if size
+          next unless value
+
+          add_agent_attribute(name, value)
+        end
+      end
+
+      def event_source_arn
+        return unless @event
+
+        # SQS/Kinesis Stream/DynamoDB/CodeCommit/S3/SNS
+        return event_source_arn_for_records if @event.fetch('Records', nil)
+
+        # Kinesis Firehose
+        ds_arn = @event.fetch('deliveryStreamArn', nil) if @event.fetch('records', nil)
+        return ds_arn if ds_arn
+
+        # ELB
+        elb_arn = @event.dig('requestContext', 'elb', 'targetGroupArn')
+        return elb_arn if elb_arn
+
+        # (other)
+        es_arn = @event.dig('resources', 0)
+        return es_arn if es_arn
+
+        NewRelic::Agent.logger.debug 'Unable to determine an event source arn'
+
+        nil
+      end
+
+      def event_source_event_info
+        return unless @event
+
+        # if every required key for a source is found, consider that source
+        # to be a match
+        EVENT_SOURCES.each_value do |info|
+          return info unless info['required_keys'].detect { |r| @event.dig(*r).nil? }
+        end
+
+        nil
+      end
+
+      def event_source_arn_for_records
+        record = @event['Records'].first
+        unless record
+          NewRelic::Agent.logger.debug "Unable to find any records in the event's 'Records' array"
+          return
+        end
+
+        arn = record.fetch('eventSourceARN', nil) || # SQS/Kinesis Stream/DynamoDB/CodeCommit
+          record.dig('s3', 'bucket', 'arn') || # S3
+          record.fetch('EventSubscriptionArn', nil) # SNS
+
+        unless arn
+          NewRelic::Agent.logger.debug "Unable to determine an event source arn from the event's 'Records' array"
+        end
+
+        arn
+      end
+
+      def add_agent_attribute(attribute, value)
+        NewRelic::Agent::Tracer.current_transaction.add_agent_attribute(attribute, value, AGENT_ATTRIBUTE_DESTINATIONS)
+      end
+
+      def process_response(response)
+        return response unless category == :web && response.respond_to?(:fetch)
+
+        http_status = response.fetch(:statusCode, response.fetch('statusCode', nil))
+        return unless http_status
+
+        add_agent_attribute('http.statusCode', http_status)
+
+        response
+      end
+
+      def cold?
+        return @cold if defined?(@cold)
+
+        @cold = false
+        true
+      end
+
+      def reset!
+        @event = nil
+        @category = nil
+        @context = nil
+        @headers = nil
+        @http_method = nil
+        @http_uri = nil
+        @payloads.replace({})
+      end
+    end
+  end
+end

data/lib/new_relic/agent/serverless_handler_event_sources.json

@@ -0,0 +1,155 @@
+{
+    "alb": {
+        "attributes": {},
+        "name": "alb",
+        "required_keys": [
+            "httpMethod",
+            "requestContext.elb"
+        ]
+    },
+
+    "apiGateway": {
+        "attributes": {
+            "aws.lambda.eventSource.accountId": "requestContext.accountId",
+            "aws.lambda.eventSource.apiId": "requestContext.apiId",
+            "aws.lambda.eventSource.resourceId": "requestContext.resourceId",
+            "aws.lambda.eventSource.resourcePath": "requestContext.resourcePath",
+            "aws.lambda.eventSource.stage": "requestContext.stage"
+        },
+        "name": "apiGateway",
+        "required_keys": [
+            "headers",
+            "httpMethod",
+            "path",
+            "requestContext",
+            "requestContext.stage"
+        ]
+    },
+
+    "apiGatewayV2": {
+        "attributes": {
+            "aws.lambda.eventSource.accountId": "requestContext.accountId",
+            "aws.lambda.eventSource.apiId": "requestContext.apiId",
+            "aws.lambda.eventSource.stage": "requestContext.stage"
+        },
+        "name": "apiGatewayV2",
+        "required_keys": [
+            "version",
+            "headers",
+            "requestContext.http",
+            "requestContext.http.path",
+            "requestContext.http.method",
+            "requestContext.stage"
+        ]
+    },
+
+    "cloudFront": {
+        "attributes": {},
+        "name": "cloudFront",
+        "required_keys": [
+            "Records[0].cf"
+        ]
+    },
+
+    "cloudWatchScheduled": {
+        "attributes": {
+            "aws.lambda.eventSource.account": "account",
+            "aws.lambda.eventSource.id": "id",
+            "aws.lambda.eventSource.region": "region",
+            "aws.lambda.eventSource.resource": "resources[0]",
+            "aws.lambda.eventSource.time": "time"
+        },
+        "name": "cloudWatch_scheduled",
+        "required_keys": [
+            "detail-type",
+            "source"
+        ]
+    },
+
+    "dynamoStreams": {
+        "attributes": {
+            "aws.lambda.eventSource.length": "Records.length"
+        },
+        "name": "dynamo_streams",
+        "required_keys": [
+            "Records[0].dynamodb"
+        ]
+    },
+
+    "firehose": {
+        "attributes": {
+            "aws.lambda.eventSource.length": "records.length",
+            "aws.lambda.eventSource.region": "region"
+        },
+        "name": "firehose",
+        "required_keys": [
+            "deliveryStreamArn",
+            "records[0].kinesisRecordMetadata"
+        ]
+    },
+
+    "kinesis": {
+        "attributes": {
+            "aws.lambda.eventSource.length": "Records.length",
+            "aws.lambda.eventSource.region": "Records[0].awsRegion"
+        },
+        "name": "kinesis",
+        "required_keys": [
+            "Records[0].kinesis"
+        ]
+    },
+
+    "s3": {
+        "attributes": {
+            "aws.lambda.eventSource.bucketName": "Records[0].s3.bucket.name",
+            "aws.lambda.eventSource.eventName": "Records[0].eventName",
+            "aws.lambda.eventSource.eventTime": "Records[0].eventTime",
+            "aws.lambda.eventSource.length": "Records.length",
+            "aws.lambda.eventSource.objectKey": "Records[0].s3.object.key",
+            "aws.lambda.eventSource.objectSequencer": "Records[0].s3.object.sequencer",
+            "aws.lambda.eventSource.objectSize": "Records[0].s3.object.size",
+            "aws.lambda.eventSource.region": "Records[0].awsRegion"
+        },
+        "name": "s3",
+        "required_keys": [
+            "Records[0].s3"
+        ]
+    },
+
+    "ses": {
+        "attributes": {
+            "aws.lambda.eventSource.date": "Records[0].ses.mail.commonHeaders.date",
+            "aws.lambda.eventSource.length": "Records.length",
+            "aws.lambda.eventSource.messageId": "Records[0].ses.mail.commonHeaders.messageId",
+            "aws.lambda.eventSource.returnPath": "Records[0].ses.mail.commonHeaders.returnPath"
+        },
+        "name": "ses",
+        "required_keys": [
+            "Records[0].ses"
+        ]
+    },
+
+    "sns": {
+        "attributes": {
+            "aws.lambda.eventSource.length": "Records.length",
+            "aws.lambda.eventSource.messageId": "Records[0].Sns.MessageId",
+            "aws.lambda.eventSource.timestamp": "Records[0].Sns.Timestamp",
+            "aws.lambda.eventSource.topicArn": "Records[0].Sns.TopicArn",
+            "aws.lambda.eventSource.type": "Records[0].Sns.Type"
+        },
+        "name": "sns",
+        "required_keys": [
+            "Records[0].Sns"
+        ]
+    },
+
+    "sqs": {
+        "attributes": {
+            "aws.lambda.eventSource.length": "Records.length"
+        },
+        "name": "sqs",
+        "required_keys": [
+            "Records[0].receiptHandle"
+        ]
+    }
+}

data/lib/new_relic/agent/serverless_handler_event_sources.rb

@@ -0,0 +1,49 @@
+# 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 'json'
+
+module NewRelic
+  module Agent
+    # ServerlessHandlerEventSources - New Relic's language agent devs maintain
+    # a cross-agent JSON map of all AWS resources with the potential to invoke
+    # an AWS Lambda function by issuing it an event. This map is used to glean
+    # source specific attributes while instrumenting the function's invocation.
+    #
+    # Given that the event arrives as a Ruby hash argument to the AWS Lambda
+    # function, the JSON map's values need to be converted into arrays that can
+    # be passed to `Hash#dig`. So a value such as `'records[0].name'` needs to
+    # be converted to `['records', 0, 'name']`. This class's `.to_hash` method
+    # yields the converted data.
+    #
+    # Furthermore, `.length` calls are converted to Ruby `#size` notation to
+    # denote that a method call must be performed on the dug value.
+    class ServerlessHandlerEventSources
+      JSON_SOURCE = File.join(File.dirname(__FILE__), 'serverless_handler_event_sources.json').freeze
+      JSON_RAW = JSON.parse(File.read(JSON_SOURCE)).freeze
+
+      def self.to_hash
+        JSON_RAW.each_with_object({}) do |(type, info), hash|
+          hash[type] = {'attributes' => {},
+                        'name' => info['name'],
+                        'required_keys' => []}
+          info['attributes'].each { |attr, value| hash[type]['attributes'][attr] = transform(value) }
+          info['required_keys'].each { |key| hash[type]['required_keys'].push(transform(key)) }
+        end.freeze
+      end
+
+      def self.transform(value)
+        value.gsub(/\[(\d+)\]/, '.\1').split('.').map do |e|
+          if e.match?(/^\d+$/)
+            e.to_i
+          elsif e == 'length'
+            '#size'
+          else
+            e
+          end
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/span_event_primitive.rb

@@ -52,6 +52,8 @@ module NewRelic
       DATASTORE_CATEGORY = 'datastore'
       CLIENT = 'client'
 
+      DB_STATEMENT_MAX_BYTES = 4096
+
       # Builds a Hash of error attributes as well as the Span ID when
       # an error is present.  Otherwise, returns nil when no error present.
       def error_attributes(segment)
@@ -79,17 +81,13 @@ module NewRelic
         intrinsics[SPAN_KIND_KEY] = CLIENT
         intrinsics[SERVER_ADDRESS_KEY] = segment.uri.host
         intrinsics[SERVER_PORT_KEY] = segment.uri.port
-        agent_attributes = error_attributes(segment) || {}
+        agent_attributes = {}
 
         if allowed?(HTTP_URL_KEY)
           agent_attributes[HTTP_URL_KEY] = truncate(segment.uri)
         end
 
-        if segment.respond_to?(:record_agent_attributes?) && segment.record_agent_attributes?
-          agent_attributes.merge!(agent_attributes(segment))
-        end
-
-        [intrinsics, custom_attributes(segment), agent_attributes]
+        [intrinsics, custom_attributes(segment), agent_attributes.merge(agent_attributes(segment))]
       end
 
       def for_datastore_segment(segment) # rubocop:disable Metrics/AbcSize
@@ -99,7 +97,7 @@ module NewRelic
         intrinsics[SPAN_KIND_KEY] = CLIENT
         intrinsics[CATEGORY_KEY] = DATASTORE_CATEGORY
 
-        agent_attributes = error_attributes(segment) || {}
+        agent_attributes = {}
 
         if segment.database_name && allowed?(DB_INSTANCE_KEY)
           agent_attributes[DB_INSTANCE_KEY] = truncate(segment.database_name)
@@ -118,12 +116,12 @@ module NewRelic
         agent_attributes[DB_SYSTEM_KEY] = segment.product if allowed?(DB_SYSTEM_KEY)
 
         if segment.sql_statement && allowed?(DB_STATEMENT_KEY)
-          agent_attributes[DB_STATEMENT_KEY] = truncate(segment.sql_statement.safe_sql, 2000)
+          agent_attributes[DB_STATEMENT_KEY] = truncate(segment.sql_statement.safe_sql, DB_STATEMENT_MAX_BYTES)
         elsif segment.nosql_statement && allowed?(DB_STATEMENT_KEY)
-          agent_attributes[DB_STATEMENT_KEY] = truncate(segment.nosql_statement, 2000)
+          agent_attributes[DB_STATEMENT_KEY] = truncate(segment.nosql_statement, DB_STATEMENT_MAX_BYTES)
         end
 
-        [intrinsics, custom_attributes(segment), agent_attributes]
+        [intrinsics, custom_attributes(segment), agent_attributes.merge(agent_attributes(segment))]
       end
 
       private

data/lib/new_relic/agent/system_info.rb

@@ -19,6 +19,20 @@ module NewRelic
         RbConfig::CONFIG['target_os']
       end
 
+      def self.os_distribution
+        case
+        when darwin? then :darwin
+        when linux? then :linux
+        when bsd? then :bsd
+        when windows? then :windows
+        else ruby_os_identifier
+        end
+      end
+
+      def self.windows?
+        !!(ruby_os_identifier[/mingw|mswin/i])
+      end
+
       def self.darwin?
         !!(ruby_os_identifier =~ /darwin/i)
       end

data/lib/new_relic/agent/threading/agent_thread.rb

@@ -9,8 +9,7 @@ module NewRelic
         def self.create(label, &blk)
           ::NewRelic::Agent.logger.debug("Creating AgentThread: #{label}")
           wrapped_blk = proc do
-            if ::Thread.current[:newrelic_tracer_state] && Thread.current[:newrelic_tracer_state].current_transaction
-              txn = ::Thread.current[:newrelic_tracer_state].current_transaction
+            if (txn = ::NewRelic::ThreadLocalStorage[:newrelic_tracer_state]&.current_transaction)
               ::NewRelic::Agent.logger.warn("AgentThread created with current transaction #{txn.best_name}")
             end
             begin