Finish unfinished Spans on Transaction completion

src/Sentry/Internal/Hub.cs

@@ -285,11 +285,16 @@ public SentryId CaptureEvent(SentryEvent evt, Scope? scope = null)
                     evt.Contexts.Trace.SpanId = linkedSpan.SpanId;
                     evt.Contexts.Trace.TraceId = linkedSpan.TraceId;
                     evt.Contexts.Trace.ParentSpanId = linkedSpan.ParentSpanId;
-                }
-                else if (evt.IsErrored() && scope?.LastCreatedSpan() is { } lastSpan && lastSpan?.IsFinished == false)
-                {
-                    // Can still be reset by the owner but lets consider it finished and errored for now.
-                    lastSpan.Finish(SpanStatus.InternalError);
+
+                    if (!linkedSpan.IsFinished && evt.IsErrored())
+                    {
+                        // Can still be reset by the owner but lets consider it finished and errored for now.
+                        linkedSpan.Finish(SpanStatus.InternalError);
+                    }
+                    else if (!linkedSpan.IsFinished)
+                    {
+                        linkedSpan.Finish();
+                    }
                 }
 
                 actualScope.SessionUpdate = evt switch

src/Sentry/SentryEventExtensions.cs

@@ -3,11 +3,14 @@
 namespace Sentry
 {
     /// <summary>
-    /// Extension methods for <see cref="SentryEvent"/>
+    /// Extension methods for <see cref="SentryEvent"/>A
     /// </summary>
     public static class SentryEventExtensions
     {
         internal static bool IsErrored(this SentryEvent @event)
-            => @event.Exception is not null || @event.SentryExceptions?.Any() == true;
+            => @event.Level >= SentryLevel.Error ||
+               @event.Exception is not null ||
+               @event.SentryExceptions?.Any() == true;
+
     }
 }

test/Sentry.Tests/HubTests.cs

@@ -285,6 +285,7 @@ public void CaptureEvent_ExceptionWithOpenSpan_SpanFinishedWithInternalError()
             var hub = new Hub(new SentryOptions
             {
                 Dsn = DsnSamples.ValidDsnWithSecret,
+                TracesSampleRate = 1
             }, client);
             var scope = new Scope();
             scope.Transaction = hub.StartTransaction("transaction", "operation");
@@ -1016,5 +1017,88 @@ public void ResumeSession_NoPausedSession_DoesNothing()
             // Assert
             client.DidNotReceive().CaptureSession(Arg.Is<SessionUpdate>(s => s.EndStatus != null));
         }
+
+        private class ErroredMessageFixture
+        {
+            public SpanId SpanId { get; }
+            public SentryId TraceId { get; }
+            public SpanId ParentId { get; }
+            public Scope Scope { get; }
+            public ISpan Span { get; }
+            public TransactionTracer Transaction { get; }
+            public IInternalScopeManager ScopeManager { get; }
+
+            public ErroredMessageFixture()
+            {
+                Scope = new Scope();
+                Transaction = new TransactionTracer(Substitute.For<IHub>(), "Tracer", "Operation");
+                Span = Transaction.StartChild("Span", "Operation");
+                ScopeManager = Substitute.For<IInternalScopeManager>();
+
+                Scope.Transaction = Transaction;
+                SpanId = Span.SpanId;
+                ParentId = Transaction.SpanId;
+                TraceId = Transaction.TraceId;
+
+                ScopeManager.GetCurrent().Returns(new KeyValuePair<Scope, ISentryClient>(Scope, Substitute.For<ISentryClient>()));
+            }
+
+            public Hub GetSut() => new Hub(new SentryOptions() { Dsn = DsnSamples.ValidDsnWithSecret }, scopeManager: ScopeManager);
+        }
+
+        private readonly ErroredMessageFixture _fixture = new();
+
+        [Theory]
+        [InlineData(SentryLevel.Error)]
+        [InlineData(SentryLevel.Fatal)]
+        public void CaptureEvent_ErroredMessageWithoutException_ClosesCurrentSpan(SentryLevel level)
+        {
+            // Arrange
+            var span = _fixture.Span;
+            var hub = _fixture.GetSut();
+
+            var @event = new SentryEvent()
+            {
+                Message = "Errored message",
+                Level = level
+            };
+
+            // Act
+            hub.CaptureEvent(@event);
+
+            // Assert
+            Assert.Equal(_fixture.SpanId, @event.Contexts.Trace.SpanId);
+            Assert.Equal(_fixture.TraceId, @event.Contexts.Trace.TraceId);
+            Assert.Equal(_fixture.ParentId, @event.Contexts.Trace.ParentSpanId);
+            Assert.True(span.IsFinished);
+            Assert.Equal(SpanStatus.InternalError, span.Status);
+        }
+
+        [Theory]
+        [InlineData(SentryLevel.Warning)]
+        [InlineData(SentryLevel.Info)]
+        [InlineData(SentryLevel.Debug)]
+        public void CaptureEvent_InfoMessageWithoutException_ClosesCurrentSpan(SentryLevel level)
+        {
+            // Arrange
+            var span = _fixture.Span;
+            var hub = _fixture.GetSut();
+
+            var @event = new SentryEvent()
+            {
+                Message = "Errored message",
+                Level = level
+            };
+
+            // Act
+            hub.CaptureEvent(@event);
+
+            // Assert
+            Assert.Equal(_fixture.SpanId, @event.Contexts.Trace.SpanId);
+            Assert.Equal(_fixture.TraceId, @event.Contexts.Trace.TraceId);
+            Assert.Equal(_fixture.ParentId, @event.Contexts.Trace.ParentSpanId);
+            Assert.True(span.IsFinished);
+            Assert.Equal(SpanStatus.UnknownError, span.Status);
+        }
     }
 }