From 53e4c9d75fd6c389b4d6ecfc66ba66ae652237ae Mon Sep 17 00:00:00 2001 From: Markus Hintersteiner Date: Mon, 6 Feb 2023 09:33:38 +0100 Subject: [PATCH 1/7] Move AppStartState write operations to SentryPerformanceProvider This way the appstart start/end times are properly tracked, even if the SDK is not initialized yet. In case of a deferred SDK init, the app start span will be attached to the first tracked Activity after SDK init. --- .../api/sentry-android-core.api | 1 + .../core/ActivityLifecycleIntegration.java | 36 ++++++------ .../io/sentry/android/core/AppStartState.java | 16 +++++ .../core/SentryPerformanceProvider.java | 17 ++++-- .../core/ActivityLifecycleIntegrationTest.kt | 58 +++++++++---------- .../core/SentryPerformanceProviderTest.kt | 24 ++++++++ 6 files changed, 98 insertions(+), 54 deletions(-) diff --git a/sentry-android-core/api/sentry-android-core.api b/sentry-android-core/api/sentry-android-core.api index f406706e92..f278ad0166 100644 --- a/sentry-android-core/api/sentry-android-core.api +++ b/sentry-android-core/api/sentry-android-core.api @@ -71,6 +71,7 @@ public final class io/sentry/android/core/AppLifecycleIntegration : io/sentry/In } public final class io/sentry/android/core/AppStartState { + public fun getAppStartEndTime ()Lio/sentry/SentryDate; public fun getAppStartInterval ()Ljava/lang/Long; public fun getAppStartMillis ()Ljava/lang/Long; public fun getAppStartTime ()Lio/sentry/SentryDate; diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/ActivityLifecycleIntegration.java b/sentry-android-core/src/main/java/io/sentry/android/core/ActivityLifecycleIntegration.java index d448c92b21..a64cf4e56c 100644 --- a/sentry-android-core/src/main/java/io/sentry/android/core/ActivityLifecycleIntegration.java +++ b/sentry-android-core/src/main/java/io/sentry/android/core/ActivityLifecycleIntegration.java @@ -210,6 +210,14 @@ private void startTracing(final @NotNull Activity activity) { getAppStartDesc(coldStart), appStartTime, Instrumenter.SENTRY); + + // in case we already have an end time, e.g. due to deferred SDK init we can already finish + // the span + final SentryDate appStartEndTime = AppStartState.getInstance().getAppStartEndTime(); + if (appStartEndTime != null) { + appStartSpan.finish(SpanStatus.OK, appStartEndTime); + } + // The first activity ttidSpan should start at the same time as the app start time ttidSpanMap.put( activity, @@ -328,26 +336,16 @@ public synchronized void onActivityStarted(final @NotNull Activity activity) { @SuppressLint("NewApi") @Override public synchronized void onActivityResumed(final @NotNull Activity activity) { - if (!firstActivityResumed) { - - // we only finish the app start if the process is of foregroundImportance - if (foregroundImportance) { - // sets App start as finished when the very first activity calls onResume - AppStartState.getInstance().setAppStartEnd(); - } else { - if (options != null) { - options - .getLogger() - .log( - SentryLevel.DEBUG, - "App Start won't be reported because Process wasn't of foregroundImportance."); - } - } + // finishes app start span + @Nullable final SentryDate appStartEndTime = AppStartState.getInstance().getAppStartEndTime(); + if (appStartSpan != null + && !appStartSpan.isFinished() + && performanceEnabled + && appStartEndTime != null) { + appStartSpan.finish(SpanStatus.OK, appStartEndTime); + } - // finishes app start span - if (performanceEnabled && appStartSpan != null) { - appStartSpan.finish(); - } + if (!firstActivityResumed) { firstActivityResumed = true; } diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/AppStartState.java b/sentry-android-core/src/main/java/io/sentry/android/core/AppStartState.java index 27e2581e28..dd008c5d64 100644 --- a/sentry-android-core/src/main/java/io/sentry/android/core/AppStartState.java +++ b/sentry-android-core/src/main/java/io/sentry/android/core/AppStartState.java @@ -1,7 +1,9 @@ package io.sentry.android.core; import android.os.SystemClock; +import io.sentry.DateUtils; import io.sentry.SentryDate; +import io.sentry.SentryLongDate; import org.jetbrains.annotations.ApiStatus; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -84,6 +86,20 @@ public SentryDate getAppStartTime() { return appStartTime; } + @Nullable + public SentryDate getAppStartEndTime() { + @Nullable final SentryDate start = getAppStartTime(); + if (start != null) { + @Nullable final Long durationMillis = getAppStartInterval(); + if (durationMillis != null) { + long startNanos = start.nanoTimestamp(); + long endNanos = startNanos + DateUtils.millisToNanos(durationMillis); + return new SentryLongDate(endNanos); + } + } + return null; + } + @Nullable public Long getAppStartMillis() { return appStartMillis; diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/SentryPerformanceProvider.java b/sentry-android-core/src/main/java/io/sentry/android/core/SentryPerformanceProvider.java index ff94c61d36..7cdf0b6688 100644 --- a/sentry-android-core/src/main/java/io/sentry/android/core/SentryPerformanceProvider.java +++ b/sentry-android-core/src/main/java/io/sentry/android/core/SentryPerformanceProvider.java @@ -29,6 +29,8 @@ public final class SentryPerformanceProvider extends EmptySecureContentProvider private static long appStartMillis = SystemClock.uptimeMillis(); private boolean firstActivityCreated = false; + private boolean firstActivityResumed = false; + private @Nullable Application application; public SentryPerformanceProvider() { @@ -91,9 +93,6 @@ public void onActivityCreated(@NotNull Activity activity, @Nullable Bundle saved final boolean coldStart = savedInstanceState == null; AppStartState.getInstance().setColdStart(coldStart); - if (application != null) { - application.unregisterActivityLifecycleCallbacks(this); - } firstActivityCreated = true; } } @@ -102,7 +101,17 @@ public void onActivityCreated(@NotNull Activity activity, @Nullable Bundle saved public void onActivityStarted(@NotNull Activity activity) {} @Override - public void onActivityResumed(@NotNull Activity activity) {} + public void onActivityResumed(@NotNull Activity activity) { + if (!firstActivityResumed) { + // we only finish the app start if the process is of foregroundImportance + firstActivityResumed = true; + // sets App start as finished when the very first activity calls onResume + AppStartState.getInstance().setAppStartEnd(); + } + if (application != null) { + application.unregisterActivityLifecycleCallbacks(this); + } + } @Override public void onActivityPaused(@NotNull Activity activity) {} diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/ActivityLifecycleIntegrationTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/ActivityLifecycleIntegrationTest.kt index 68acc87fd5..98453ab7be 100644 --- a/sentry-android-core/src/test/java/io/sentry/android/core/ActivityLifecycleIntegrationTest.kt +++ b/sentry-android-core/src/test/java/io/sentry/android/core/ActivityLifecycleIntegrationTest.kt @@ -650,66 +650,62 @@ class ActivityLifecycleIntegrationTest { } @Test - fun `App start end time is set`() { - val sut = fixture.getSut(14) - fixture.options.tracesSampleRate = 1.0 - sut.register(fixture.hub, fixture.options) - - setAppStartTime() - - val activity = mock() - sut.onActivityCreated(activity, null) - sut.onActivityResumed(activity) - - // SystemClock.uptimeMillis() always returns 0, can't assert real values - assertNotNull(AppStartState.getInstance().appStartInterval) - } - - @Test - fun `App start end time isnt set if not foregroundImportance`() { - val sut = fixture.getSut(14, importance = RunningAppProcessInfo.IMPORTANCE_BACKGROUND) + fun `When firstActivityCreated is true, start transaction with given appStartTime`() { + val sut = fixture.getSut() fixture.options.tracesSampleRate = 1.0 sut.register(fixture.hub, fixture.options) - setAppStartTime() + val date = SentryNanotimeDate(Date(0), 0) + setAppStartTime(date) val activity = mock() - sut.onActivityCreated(activity, null) - sut.onActivityResumed(activity) + sut.onActivityCreated(activity, fixture.bundle) - assertNull(AppStartState.getInstance().appStartInterval) + // call only once + verify(fixture.hub).startTransaction(any(), check { assertEquals(date, it.startTimestamp) }) } @Test - fun `When firstActivityCreated is true, start transaction with given appStartTime`() { - val sut = fixture.getSut() + fun `When firstActivityCreated is true, do not create app start span if not foregroundImportance`() { + val sut = fixture.getSut(importance = RunningAppProcessInfo.IMPORTANCE_BACKGROUND) fixture.options.tracesSampleRate = 1.0 sut.register(fixture.hub, fixture.options) + // usually set by SentryPerformanceProvider val date = SentryNanotimeDate(Date(0), 0) setAppStartTime(date) + AppStartState.getInstance().setAppStartEnd(1) val activity = mock() sut.onActivityCreated(activity, fixture.bundle) // call only once - verify(fixture.hub).startTransaction(any(), check { assertEquals(date, it.startTimestamp) }) + verify(fixture.hub).startTransaction(any(), check { assertNull(it.startTimestamp) }) } @Test - fun `When firstActivityCreated is true, do not use appStartTime if not foregroundImportance`() { - val sut = fixture.getSut(importance = RunningAppProcessInfo.IMPORTANCE_BACKGROUND) + fun `Create and finish app start span immediately in case SDK init is deferred`() { + val sut = fixture.getSut(importance = RunningAppProcessInfo.IMPORTANCE_FOREGROUND) fixture.options.tracesSampleRate = 1.0 sut.register(fixture.hub, fixture.options) - val date = SentryNanotimeDate(Date(0), 0) - setAppStartTime(date) + // usually set by SentryPerformanceProvider + val startDate = SentryNanotimeDate(Date(0), 0) + setAppStartTime(startDate) + AppStartState.getInstance().setColdStart(false) + AppStartState.getInstance().setAppStartEnd(1) + + val endDate = AppStartState.getInstance().appStartEndTime!! val activity = mock() sut.onActivityCreated(activity, fixture.bundle) - // call only once - verify(fixture.hub).startTransaction(any(), check { assertNull(it.startTimestamp) }) + val appStartSpanCount = fixture.transaction.children.count { + it.spanContext.operation.startsWith("app.start.warm") && + it.startDate.nanoTimestamp() == startDate.nanoTimestamp() && + it.finishDate!!.nanoTimestamp() == endDate.nanoTimestamp() + } + assertEquals(1, appStartSpanCount) } @Test diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/SentryPerformanceProviderTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/SentryPerformanceProviderTest.kt index 611c087dd1..cf3ca7c2ea 100644 --- a/sentry-android-core/src/test/java/io/sentry/android/core/SentryPerformanceProviderTest.kt +++ b/sentry-android-core/src/test/java/io/sentry/android/core/SentryPerformanceProviderTest.kt @@ -1,16 +1,20 @@ package io.sentry.android.core +import android.app.Application import android.content.pm.ProviderInfo import android.os.Bundle import androidx.test.ext.junit.runners.AndroidJUnit4 import io.sentry.SentryNanotimeDate import org.junit.runner.RunWith +import org.mockito.kotlin.any import org.mockito.kotlin.mock +import org.mockito.kotlin.verify import java.util.Date import kotlin.test.BeforeTest import kotlin.test.Test import kotlin.test.assertEquals import kotlin.test.assertFalse +import kotlin.test.assertNotNull import kotlin.test.assertTrue @RunWith(AndroidJUnit4::class) @@ -73,6 +77,26 @@ class SentryPerformanceProviderTest { assertFalse(AppStartState.getInstance().isColdStart!!) } + @Test + fun `provider sets app start end on first activity resume, and unregisters afterwards`() { + val providerInfo = ProviderInfo() + + val mockContext = ContextUtilsTest.createMockContext(true) + providerInfo.authority = AUTHORITY + + val provider = SentryPerformanceProvider() + provider.attachInfo(mockContext, providerInfo) + + provider.onActivityCreated(mock(), Bundle()) + provider.onActivityResumed(mock()) + + assertNotNull(AppStartState.getInstance().appStartInterval) + assertNotNull(AppStartState.getInstance().appStartEndTime) + + verify((mockContext.applicationContext as Application)) + .unregisterActivityLifecycleCallbacks(any()) + } + companion object { private const val AUTHORITY = "io.sentry.sample.SentryPerformanceProvider" } From 389cafe47490df57bc4cbc757cb87f03aa0e6bf1 Mon Sep 17 00:00:00 2001 From: Markus Hintersteiner Date: Mon, 6 Feb 2023 09:51:59 +0100 Subject: [PATCH 2/7] Update changelog --- CHANGELOG.md | 1 + 1 file changed, 1 insertion(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 739bd707b2..fdf9b64dba 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -7,6 +7,7 @@ - Fix transaction performance collector oom ([#2505](https://github.com/getsentry/sentry-java/pull/2505)) - Remove authority from URLs sent to Sentry ([#2366](https://github.com/getsentry/sentry-java/pull/2366)) - Fix `sentry-bom` containing incorrect artifacts ([#2504](https://github.com/getsentry/sentry-java/pull/2504)) +- Fix app start span end-time is wrong if SDK init is deferred ([#2519](https://github.com/getsentry/sentry-java/pull/2519)) ### Dependencies From c67673563c27536f8b0b8813eee0daa4a392bf7f Mon Sep 17 00:00:00 2001 From: Markus Hintersteiner Date: Mon, 6 Feb 2023 09:52:06 +0100 Subject: [PATCH 3/7] Fix typos --- .../src/main/java/io/sentry/android/core/AppStartState.java | 4 ++-- .../io/sentry/android/core/SentryPerformanceProvider.java | 3 +-- 2 files changed, 3 insertions(+), 4 deletions(-) diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/AppStartState.java b/sentry-android-core/src/main/java/io/sentry/android/core/AppStartState.java index dd008c5d64..de690aa668 100644 --- a/sentry-android-core/src/main/java/io/sentry/android/core/AppStartState.java +++ b/sentry-android-core/src/main/java/io/sentry/android/core/AppStartState.java @@ -92,8 +92,8 @@ public SentryDate getAppStartEndTime() { if (start != null) { @Nullable final Long durationMillis = getAppStartInterval(); if (durationMillis != null) { - long startNanos = start.nanoTimestamp(); - long endNanos = startNanos + DateUtils.millisToNanos(durationMillis); + final long startNanos = start.nanoTimestamp(); + final long endNanos = startNanos + DateUtils.millisToNanos(durationMillis); return new SentryLongDate(endNanos); } } diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/SentryPerformanceProvider.java b/sentry-android-core/src/main/java/io/sentry/android/core/SentryPerformanceProvider.java index 7cdf0b6688..7ba270351b 100644 --- a/sentry-android-core/src/main/java/io/sentry/android/core/SentryPerformanceProvider.java +++ b/sentry-android-core/src/main/java/io/sentry/android/core/SentryPerformanceProvider.java @@ -103,9 +103,8 @@ public void onActivityStarted(@NotNull Activity activity) {} @Override public void onActivityResumed(@NotNull Activity activity) { if (!firstActivityResumed) { - // we only finish the app start if the process is of foregroundImportance - firstActivityResumed = true; // sets App start as finished when the very first activity calls onResume + firstActivityResumed = true; AppStartState.getInstance().setAppStartEnd(); } if (application != null) { From be4df72e06f99acd482d2e88cda3055cd57dd004 Mon Sep 17 00:00:00 2001 From: Markus Hintersteiner Date: Tue, 7 Feb 2023 08:15:31 +0100 Subject: [PATCH 4/7] Fix handling when SentryPerformanceProvider is disabled --- .../core/ActivityLifecycleIntegration.java | 44 ++++++++++------- .../core/ActivityLifecycleIntegrationTest.kt | 49 +++++++++++++++++++ 2 files changed, 75 insertions(+), 18 deletions(-) diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/ActivityLifecycleIntegration.java b/sentry-android-core/src/main/java/io/sentry/android/core/ActivityLifecycleIntegration.java index a64cf4e56c..4e00390771 100644 --- a/sentry-android-core/src/main/java/io/sentry/android/core/ActivityLifecycleIntegration.java +++ b/sentry-android-core/src/main/java/io/sentry/android/core/ActivityLifecycleIntegration.java @@ -56,8 +56,7 @@ public final class ActivityLifecycleIntegration private boolean isAllActivityCallbacksAvailable; private boolean firstActivityCreated = false; - private boolean firstActivityResumed = false; - private boolean foregroundImportance = false; + private final boolean foregroundImportance; private @Nullable ISpan appStartSpan; private final @NotNull WeakHashMap ttidSpanMap = new WeakHashMap<>(); @@ -211,12 +210,9 @@ private void startTracing(final @NotNull Activity activity) { appStartTime, Instrumenter.SENTRY); - // in case we already have an end time, e.g. due to deferred SDK init we can already finish - // the span - final SentryDate appStartEndTime = AppStartState.getInstance().getAppStartEndTime(); - if (appStartEndTime != null) { - appStartSpan.finish(SpanStatus.OK, appStartEndTime); - } + // in case there's already an end time (e.g. due to deferred SDK init) + // we can finish the app-start span + finishAppStartSpan(); // The first activity ttidSpan should start at the same time as the app start time ttidSpanMap.put( @@ -336,18 +332,17 @@ public synchronized void onActivityStarted(final @NotNull Activity activity) { @SuppressLint("NewApi") @Override public synchronized void onActivityResumed(final @NotNull Activity activity) { - // finishes app start span - @Nullable final SentryDate appStartEndTime = AppStartState.getInstance().getAppStartEndTime(); - if (appStartSpan != null - && !appStartSpan.isFinished() - && performanceEnabled - && appStartEndTime != null) { - appStartSpan.finish(SpanStatus.OK, appStartEndTime); - } - if (!firstActivityResumed) { - firstActivityResumed = true; + // app start span + @Nullable final SentryDate appStartStartTime = AppStartState.getInstance().getAppStartTime(); + @Nullable final SentryDate appStartEndTime = AppStartState.getInstance().getAppStartEndTime(); + // in case the SentryPerformanceProvider is disabled it does not set the app start times, + // and we need to set the end time manually here, + // the start time gets set manually in SentryAndroid.init() + if (appStartStartTime != null && appStartEndTime == null) { + AppStartState.getInstance().setAppStartEnd(); } + finishAppStartSpan(); final ISpan ttidSpan = ttidSpanMap.get(activity); final View rootView = activity.findViewById(android.R.id.content); @@ -505,4 +500,17 @@ private void setColdStart(final @Nullable Bundle savedInstanceState) { return APP_START_WARM; } } + + private void finishAppStartSpan() { + final @Nullable SentryDate appStartEndTime = AppStartState.getInstance().getAppStartEndTime(); + if (appStartSpan != null + && !appStartSpan.isFinished() + && performanceEnabled + && appStartEndTime != null) { + + final SpanStatus status = + appStartSpan.getStatus() != null ? appStartSpan.getStatus() : SpanStatus.OK; + appStartSpan.finish(status, appStartEndTime); + } + } } diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/ActivityLifecycleIntegrationTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/ActivityLifecycleIntegrationTest.kt index 98453ab7be..06d01c2131 100644 --- a/sentry-android-core/src/test/java/io/sentry/android/core/ActivityLifecycleIntegrationTest.kt +++ b/sentry-android-core/src/test/java/io/sentry/android/core/ActivityLifecycleIntegrationTest.kt @@ -6,6 +6,7 @@ import android.app.ActivityManager.RunningAppProcessInfo import android.app.Application import android.os.Bundle import io.sentry.Breadcrumb +import io.sentry.DateUtils import io.sentry.Hub import io.sentry.Scope import io.sentry.SentryDate @@ -708,6 +709,54 @@ class ActivityLifecycleIntegrationTest { assertEquals(1, appStartSpanCount) } + @Test + fun `When SentryPerformanceProvider is disabled, app start time span is still created`() { + val sut = fixture.getSut(importance = RunningAppProcessInfo.IMPORTANCE_FOREGROUND) + fixture.options.tracesSampleRate = 1.0 + sut.register(fixture.hub, fixture.options) + + // usually done by SentryPerformanceProvider, if disabled it's done by + // SentryAndroid.init + val startDate = SentryNanotimeDate(Date(0), 0) + setAppStartTime(startDate) + AppStartState.getInstance().setColdStart(false) + + // when activity is created + val activity = mock() + sut.onActivityCreated(activity, fixture.bundle) + // then app-start end time should still be null + assertNull(AppStartState.getInstance().appStartEndTime) + + // when activity is resumed + sut.onActivityResumed(activity) + // end-time should be set + assertNotNull(AppStartState.getInstance().appStartEndTime) + } + + @Test + fun `When app-start end time is already set, it should not be overwritten`() { + val sut = fixture.getSut(importance = RunningAppProcessInfo.IMPORTANCE_FOREGROUND) + fixture.options.tracesSampleRate = 1.0 + sut.register(fixture.hub, fixture.options) + + // usually done by SentryPerformanceProvider + val startDate = SentryNanotimeDate(Date(0), 0) + setAppStartTime(startDate) + AppStartState.getInstance().setColdStart(false) + AppStartState.getInstance().setAppStartEnd(1234) + + // when activity is created and resumed + val activity = mock() + sut.onActivityCreated(activity, fixture.bundle) + sut.onActivityResumed(activity) + + // then the end time should not be overwritten + assertEquals( + DateUtils.millisToNanos(1234), + AppStartState.getInstance().appStartEndTime!!.nanoTimestamp() + ) + } + @Test fun `When firstActivityCreated is true, start app start warm span with given appStartTime`() { val sut = fixture.getSut() From 91e16e77a7de0fa1c341f9c5335108e3e84e5529 Mon Sep 17 00:00:00 2001 From: Markus Hintersteiner Date: Tue, 7 Feb 2023 14:22:26 +0100 Subject: [PATCH 5/7] Ensure multiple activity lifecycle events do not overwrite app-start end time --- .../core/ActivityLifecycleIntegrationTest.kt | 32 +++++++++++++++++++ 1 file changed, 32 insertions(+) diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/ActivityLifecycleIntegrationTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/ActivityLifecycleIntegrationTest.kt index 06d01c2131..1f3005a5fe 100644 --- a/sentry-android-core/src/test/java/io/sentry/android/core/ActivityLifecycleIntegrationTest.kt +++ b/sentry-android-core/src/test/java/io/sentry/android/core/ActivityLifecycleIntegrationTest.kt @@ -757,6 +757,38 @@ class ActivityLifecycleIntegrationTest { ) } + @Test + fun `When activity lifecycle happens multiple times, app-start end time should not be overwritten`() { + val sut = fixture.getSut(importance = RunningAppProcessInfo.IMPORTANCE_FOREGROUND) + fixture.options.tracesSampleRate = 1.0 + sut.register(fixture.hub, fixture.options) + + // usually done by SentryPerformanceProvider + val startDate = SentryNanotimeDate(Date(0), 0) + setAppStartTime(startDate) + AppStartState.getInstance().setColdStart(false) + + // when activity is created, started and resumed multiple times + val activity = mock() + sut.onActivityCreated(activity, fixture.bundle) + sut.onActivityStarted(activity) + sut.onActivityResumed(activity) + + val firstAppStartEndTime = AppStartState.getInstance().appStartEndTime + + Thread.sleep(1) + sut.onActivityPaused(activity) + sut.onActivityStopped(activity) + sut.onActivityStarted(activity) + sut.onActivityResumed(activity) + + // then the end time should not be overwritten + assertEquals( + firstAppStartEndTime!!.nanoTimestamp(), + AppStartState.getInstance().appStartEndTime!!.nanoTimestamp() + ) + } + @Test fun `When firstActivityCreated is true, start app start warm span with given appStartTime`() { val sut = fixture.getSut() From b5ba7ee1d10fc9bcffb007ac6d9e7893b7ed2033 Mon Sep 17 00:00:00 2001 From: Markus Hintersteiner Date: Tue, 7 Feb 2023 15:19:19 +0100 Subject: [PATCH 6/7] Fix Changelog --- CHANGELOG.md | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index a37db3831f..06b5918bd0 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,13 +1,18 @@ # Changelog +## Unreleased + +### Fixes + ## 6.13.1 +- Fix app start span end-time is wrong if SDK init is deferred ([#2519](https://github.com/getsentry/sentry-java/pull/2519)) + ### Fixes - Fix transaction performance collector oom ([#2505](https://github.com/getsentry/sentry-java/pull/2505)) - Remove authority from URLs sent to Sentry ([#2366](https://github.com/getsentry/sentry-java/pull/2366)) - Fix `sentry-bom` containing incorrect artifacts ([#2504](https://github.com/getsentry/sentry-java/pull/2504)) -- Fix app start span end-time is wrong if SDK init is deferred ([#2519](https://github.com/getsentry/sentry-java/pull/2519)) ### Dependencies From 002308d1b38fe0593cc47d858d1d592b9e04bf34 Mon Sep 17 00:00:00 2001 From: Markus Hintersteiner Date: Tue, 7 Feb 2023 15:31:01 +0100 Subject: [PATCH 7/7] Fix Changelog --- CHANGELOG.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 06b5918bd0..49c8cae9e9 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -4,10 +4,10 @@ ### Fixes -## 6.13.1 - - Fix app start span end-time is wrong if SDK init is deferred ([#2519](https://github.com/getsentry/sentry-java/pull/2519)) +## 6.13.1 + ### Fixes - Fix transaction performance collector oom ([#2505](https://github.com/getsentry/sentry-java/pull/2505))