I've tried something similar as what is in SentryTracingFilter, but I think it needs some specifics to bind it to the reactor context.

Click to expand code

package oopen.timemachine.config

import io.sentry.CustomSamplingContext
import io.sentry.HubAdapter
import io.sentry.ITransaction
import io.sentry.SentryLevel
import io.sentry.SentryTraceHeader
import io.sentry.SpanStatus
import io.sentry.TransactionContext
import io.sentry.exception.InvalidSentryTraceHeaderException
import org.springframework.http.server.reactive.ServerHttpRequest
import org.springframework.stereotype.Component
import org.springframework.web.reactive.HandlerMapping
import org.springframework.web.server.ServerWebExchange
import org.springframework.web.server.WebFilter
import org.springframework.web.server.WebFilterChain
import org.springframework.web.util.pattern.PathPattern
import reactor.core.publisher.Mono

@Component
class SentryTransactionWebFilter(private val hub: HubAdapter = HubAdapter.getInstance()) : WebFilter {
    companion object {
        private const val TRANSACTION_OP = "http.server"
    }

    override fun filter(exchange: ServerWebExchange, chain: WebFilterChain): Mono<Void> {
        val sentryTraceHeader = exchange.request.headers.getFirst(SentryTraceHeader.SENTRY_TRACE_HEADER)

        // at this stage we are not able to get real transaction name
        val transaction = startTransaction(exchange.request, sentryTraceHeader);

        return chain.filter(exchange).doFinally {
            // after all filters run, templated path pattern is available in request attribute
            val transactionName = provideTransactionName(exchange);
            // if transaction name is not resolved, the request has not been processed by a controller
            // and we should not report it to Sentry
            if (transactionName != null) {
                transaction.name = transactionName;
                transaction.operation = TRANSACTION_OP;
                // if exception has been thrown, transaction status is already set to INTERNAL_ERROR, and
                // httpResponse.getStatus() returns 200.
                if (transaction.status == null) {
                    transaction.status = SpanStatus.fromHttpStatusCode(exchange.response.rawStatusCode ?: 0);
                }
                transaction.finish();
            }
        }.doOnError {
            transaction.status = SpanStatus.INTERNAL_ERROR
            transaction.throwable = it
        }
    }

    private fun startTransaction(request: ServerHttpRequest, sentryTraceHeader: String?): ITransaction {
        val name = "${request.methodValue} ${request.uri}"
        val customSamplingContext = CustomSamplingContext()
        customSamplingContext["request"] = request
        if (sentryTraceHeader != null) {
            try {
                val contexts = TransactionContext.fromSentryTrace(
                    name, TRANSACTION_OP, SentryTraceHeader(sentryTraceHeader)
                )
                return hub.startTransaction(contexts, customSamplingContext, true)
            } catch (e: InvalidSentryTraceHeaderException) {
                hub.options.logger
                    .log(SentryLevel.DEBUG, e, "Failed to parse Sentry trace header: %s", e.message)
            }
        }
        return hub.startTransaction(name, "http.server", customSamplingContext, true)
    }

    // Could be `io.sentry.spring.webflux.TransactionNameProvider`, but that class is private.
    private fun provideTransactionName(
        serverWebExchange: ServerWebExchange
    ): String? {
        val pattern = serverWebExchange.getAttribute<PathPattern>(HandlerMapping.BEST_MATCHING_PATTERN_ATTRIBUTE)
        return if (pattern != null) {
            serverWebExchange.request.methodValue + " " + pattern.patternString
        } else {
            null
        }
    }
}

Uh oh!

Automatic performance transactions for Webflux #1807

Description

Metadata

Metadata

Assignees

Labels

Fields

Projects

Milestone

Relationships

Development

Issue actions