Merge branch 'main' into lcian/fix/cowal-iterator

Author: lcian

.gitignore

@@ -20,3 +20,4 @@ distributions/
 sentry-spring-boot-starter-jakarta/src/main/resources/META-INF/spring.factories
 sentry-samples/sentry-samples-spring-boot-jakarta/spy.log
 spy.log
+buildSrc/.kotlin/

CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## Unreleased
 
+### Behavioural Changes
+
+- Use `java.net.URI` for parsing URLs in `UrlUtils` ([#4210](https://github.com/getsentry/sentry-java/pull/4210))
+  - This could affect grouping for issues with messages containing URLs that fall in known corner cases that were handled incorrectly previously (e.g. email in URL path)
+
 ### Fixes
 
 - Add support for setting in-app-includes/in-app-excludes via AndroidManifest.xml ([#4240](https://github.com/getsentry/sentry-java/pull/4240))
@@ -11,11 +16,17 @@
 ### Features
 
 - The SDK now automatically propagates the trace-context to the native layer. This allows to connect errors on different layers of the application. ([#4137](https://github.com/getsentry/sentry-java/pull/4137))
+- Capture OpenTelemetry span events ([#3564](https://github.com/getsentry/sentry-java/pull/3564))
+  - OpenTelemetry spans may have exceptions attached to them (`openTelemetrySpan.recordException`). We can now send those to Sentry as errors.
+  - Set `capture-open-telemetry-events=true` in `sentry.properties` to enable it
+  - Set `sentry.capture-open-telemetry-events=true` in Springs `application.properties` to enable it
+  - Set `sentry.captureOpenTelemetryEvents: true` in Springs `application.yml` to enable it
 
-### Behavioural Changes
+### Internal
 
-- Use `java.net.URI` for parsing URLs in `UrlUtils` ([#4210](https://github.com/getsentry/sentry-java/pull/4210))
-  - This could affect grouping for issues with messages containing URLs that fall in known corner cases that were handled incorrectly previously (e.g. email in URL path)
+- Also use port when checking if a request is made to Sentry DSN ([#4231](https://github.com/getsentry/sentry-java/pull/4231))
+  - For our OpenTelemetry integration we check if a span is for a request to Sentry
+  - We now also consider the port when performing this check
 
 ### Dependencies
 

sentry-opentelemetry/sentry-opentelemetry-core/src/main/java/io/sentry/opentelemetry/OpenTelemetryAttributesExtractor.java

@@ -105,13 +105,20 @@ private static Map<String, String> collectHeaders(
     return headers;
   }
 
+  @SuppressWarnings("deprecation")
   public @Nullable String extractUrl(
       final @NotNull Attributes attributes, final @NotNull SentryOptions options) {
     final @Nullable String urlFull = attributes.get(UrlAttributes.URL_FULL);
     if (urlFull != null) {
       return urlFull;
     }
 
+    final @Nullable String deprecatedUrl =
+        attributes.get(io.opentelemetry.semconv.SemanticAttributes.HTTP_URL);
+    if (deprecatedUrl != null) {
+      return deprecatedUrl;
+    }
+
     final String urlString = buildUrlString(attributes, options);
     if (!urlString.isEmpty()) {
       return urlString;

sentry-opentelemetry/sentry-opentelemetry-core/src/main/java/io/sentry/opentelemetry/OtelInternalSpanDetectionUtil.java

@@ -2,7 +2,6 @@
 
 import io.opentelemetry.api.common.Attributes;
 import io.opentelemetry.api.trace.SpanKind;
-import io.opentelemetry.semconv.UrlAttributes;
 import io.sentry.DsnUtil;
 import io.sentry.IScopes;
 import java.util.Arrays;
@@ -17,6 +16,8 @@ public final class OtelInternalSpanDetectionUtil {
 
   private static final @NotNull List<SpanKind> spanKindsConsideredForSentryRequests =
       Arrays.asList(SpanKind.CLIENT, SpanKind.INTERNAL);
+  private static final @NotNull OpenTelemetryAttributesExtractor attributesExtractor =
+      new OpenTelemetryAttributesExtractor();
 
   @SuppressWarnings("deprecation")
   public static boolean isSentryRequest(
@@ -27,14 +28,8 @@ public static boolean isSentryRequest(
       return false;
     }
 
-    final @Nullable String httpUrl =
-        attributes.get(io.opentelemetry.semconv.SemanticAttributes.HTTP_URL);
-    if (DsnUtil.urlContainsDsnHost(scopes.getOptions(), httpUrl)) {
-      return true;
-    }
-
-    final @Nullable String fullUrl = attributes.get(UrlAttributes.URL_FULL);
-    if (DsnUtil.urlContainsDsnHost(scopes.getOptions(), fullUrl)) {
+    String url = attributesExtractor.extractUrl(attributes, scopes.getOptions());
+    if (DsnUtil.urlContainsDsnHost(scopes.getOptions(), url)) {
       return true;
     }
 
@@ -43,10 +38,7 @@ public static boolean isSentryRequest(
       final @NotNull String spotlightUrl =
           optionsSpotlightUrl != null ? optionsSpotlightUrl : "http://localhost:8969/stream";
 
-      if (containsSpotlightUrl(fullUrl, spotlightUrl)) {
-        return true;
-      }
-      if (containsSpotlightUrl(httpUrl, spotlightUrl)) {
+      if (containsSpotlightUrl(url, spotlightUrl)) {
         return true;
       }
     }

sentry-opentelemetry/sentry-opentelemetry-core/src/main/java/io/sentry/opentelemetry/OtelSentrySpanProcessor.java

@@ -8,18 +8,25 @@
 import io.opentelemetry.sdk.trace.ReadWriteSpan;
 import io.opentelemetry.sdk.trace.ReadableSpan;
 import io.opentelemetry.sdk.trace.SpanProcessor;
+import io.opentelemetry.sdk.trace.data.EventData;
+import io.opentelemetry.sdk.trace.data.ExceptionEventData;
 import io.sentry.Baggage;
+import io.sentry.DateUtils;
 import io.sentry.IScopes;
 import io.sentry.PropagationContext;
 import io.sentry.ScopesAdapter;
 import io.sentry.Sentry;
 import io.sentry.SentryDate;
+import io.sentry.SentryEvent;
 import io.sentry.SentryLevel;
 import io.sentry.SentryLongDate;
 import io.sentry.SentryTraceHeader;
 import io.sentry.SpanId;
 import io.sentry.TracesSamplingDecision;
+import io.sentry.exception.ExceptionMechanismException;
+import io.sentry.protocol.Mechanism;
 import io.sentry.protocol.SentryId;
+import java.util.List;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -143,9 +150,46 @@ public void onEnd(final @NotNull ReadableSpan spanBeingEnded) {
       final @NotNull SentryDate finishDate =
           new SentryLongDate(spanBeingEnded.toSpanData().getEndEpochNanos());
       sentrySpan.updateEndDate(finishDate);
+
+      maybeCaptureSpanEventsAsExceptions(spanBeingEnded, sentrySpan);
     }
   }
 
+  private void maybeCaptureSpanEventsAsExceptions(
+      final @NotNull ReadableSpan spanBeingEnded, final @NotNull IOtelSpanWrapper sentrySpan) {
+    final @NotNull IScopes spanScopes = sentrySpan.getScopes();
+    if (spanScopes.getOptions().isCaptureOpenTelemetryEvents()) {
+      final @NotNull List<EventData> events = spanBeingEnded.toSpanData().getEvents();
+      for (EventData event : events) {
+        if (event instanceof ExceptionEventData) {
+          final @NotNull ExceptionEventData exceptionEvent = (ExceptionEventData) event;
+          captureException(spanScopes, exceptionEvent, sentrySpan);
+        }
+      }
+    }
+  }
+
+  private void captureException(
+      final @NotNull IScopes scopes,
+      final @NotNull ExceptionEventData exceptionEvent,
+      final @NotNull IOtelSpanWrapper sentrySpan) {
+    final @NotNull Throwable exception = exceptionEvent.getException();
+    final Mechanism mechanism = new Mechanism();
+    mechanism.setType("OpenTelemetrySpanEvent");
+    mechanism.setHandled(true);
+    // This is potentially the wrong Thread as it's the current thread meaning the thread where
+    // the span is being ended on. This may not match the thread where the exception occurred.
+    final Throwable mechanismException =
+        new ExceptionMechanismException(mechanism, exception, Thread.currentThread());
+
+    final SentryEvent event = new SentryEvent(mechanismException);
+    event.setTimestamp(DateUtils.nanosToDate(exceptionEvent.getEpochNanos()));
+    event.setLevel(SentryLevel.ERROR);
+    event.getContexts().setTrace(sentrySpan.getSpanContext());
+
+    scopes.captureEvent(event);
+  }
+
   @Override
   public boolean isEndRequired() {
     return true;

sentry-opentelemetry/sentry-opentelemetry-core/src/test/kotlin/OpenTelemetryAttributesExtractorTest.kt

@@ -4,6 +4,7 @@ import io.opentelemetry.api.common.AttributeKey
 import io.opentelemetry.sdk.internal.AttributesMap
 import io.opentelemetry.sdk.trace.data.SpanData
 import io.opentelemetry.semconv.HttpAttributes
+import io.opentelemetry.semconv.SemanticAttributes
 import io.opentelemetry.semconv.ServerAttributes
 import io.opentelemetry.semconv.UrlAttributes
 import io.sentry.Scope
@@ -202,6 +203,19 @@ class OpenTelemetryAttributesExtractorTest {
         assertEquals("https://sentry.io/some/path", url)
     }
 
+    @Test
+    fun `returns deprecated URL if present`() {
+        givenAttributes(
+            mapOf(
+                SemanticAttributes.HTTP_URL to "https://sentry.io/some/path"
+            )
+        )
+
+        val url = whenExtractingUrl()
+
+        assertEquals("https://sentry.io/some/path", url)
+    }
+
     @Test
     fun `returns reconstructed URL if attributes present`() {
         givenAttributes(