AppCenter migration, Events and customProperties

[munkii]

We are currently using Microsoft's AppCenter in our Xamarin Forms application but with our ongoing MAUI migration and AppCenter's upcoming retirement we are looking at Sentry to replace it.

My experience of analytics has been AppCenter or Google Analytics for web and I am trying to best see how our use of AppCenter would fit into Sentry.

We use Analytics.TrackEvent and Analytics.TrackError for handled exceptions. We have calls from all over the code base that pass in an unstructured set of KeyValuePair<string, string> that get attached as customProperties in to tracked events. We also export our AppCenter to Azure AppInsights for more detailed querying.

Here are some examples of our "TrackedEvents"

• "User Action - Tile Tapped - Tile:Steps"
• "ViewModel - StepsHistoryViewModel Appearing"
• "Start Bluetooth Device setup"
• "Capture Session ended. User has completed 3 measurements"
• "MyFeature - User opted to Call Later"

These are also tracked as events but we also tag them with customProperties

• "Failed to connect to BT device"
  • SerialNumber
• "Data preference changed"
  • MeasurementType
  • NewPreference
  • OldPreference
• "Feature banner tapped"
  • FeautureState
• "BT capture test timed out"
  • DeviceName

These don't all seem like issues in the Sentry sense of the word or have i misunderstood "Issues"

It also looks like breadcrumbing would replace our logging of every time we load a ViewModel with "ViewModel - {ViewModelName} Appearing", is that a valid understanding?

The ones that have extra data associated with them; this topic was discussed here, AppCenter retirement - Migration guides and you suggested "Structured Context". These are part of Scopes, would we make a ConfigureScope call just before the SentrySdk.CaptureMessage? Is that "Scope" just for the following call or is there the concept of "descoping" that we need to make before making another call?

I also notice you can add a Sentryuser in ConfigureScope call. Currently we tag all AppCenter evevnts with a custom property of userId which is the Azure Ad B2C object id of our authenticated user. Is this hjow we would do that?

SentrySdk.ConfigureScope(scope =>
        {
            scope.User = new SentryUser
            {
                Username = {B2C_ObjectId},
            };
        });

[jamescrosswell]

@munkii I think Sentry has a few features that are analogous to the things you're using in AppCenter:

1. Issues - Basically crash reporting... although you can do things like SentrySdk.CaptureMessage and that will show up as an issue too (even though there's no exception present)
2. Tracing - if you enable tracing by configuring the tracing sample rate to something other than 0.0, you can get traces out of Sentry. These are great for tracking things with a duration. For example, you could start a trace before downloading a file from the internet and finish it once the file had been downloaded. Sentry's has various integrations that give you automatic tracing without you having to manually instrument anything.
3. Breadcrumbs - these are used to record that something happened, but without measuring how long it took... for example: "the user clicked on this button". The breadcrumb history gets sent as additional context along with any issue that are captured by Sentry.

Like breadcrumbs, scopes can be used to store other "ambient" context that will be sent with issues and traces... Sentry maintains scope information in a stack data structure.

When you call SentrySdk.ConfigureScope, you're basically modifying whatever scope is sitting on top of the stack (aka the current scope). Anything that is stored on the current scope will be sent with any future events that get sent (issues, traces etc.).

Alternatively, if you wanted to store something in the scope "temporarily", you could push a new clone of the current scope to the stack, store what you want in that scope, capture the event in question and then pop that scope from the stack (to return the scope to the state it was in before you started fiddling with it). Lots of the methods in the SentrySdk include overrides that allow you to do that with minimal ceremony. For example, the CaptureMessage method has accepts an Action<Scope> callback that you can use to make modifications to the scope that will only be applied for the purposes of capturing that specific exception:

sentry-dotnet/src/Sentry/SentrySdk.cs

Lines 471 to 483 in 5ff8acc

	/// <summary>
	/// Captures the message with a configurable scope.
	/// </summary>
	/// <remarks>
	/// This allows modifying a scope without affecting other events.
	/// </remarks>
	/// <param name="message">The message to send.</param>
	/// <param name="configureScope">The callback to configure the scope.</param>
	/// <param name="level">The message level.</param>
	/// <returns>The Id of the event.</returns>
	[DebuggerStepThrough]
	public static SentryId CaptureMessage(string message, Action<Scope> configureScope, SentryLevel level = SentryLevel.Info)
	=> CurrentHub.CaptureMessage(message, configureScope, level);

Note: There's one other subtlety to the scope in Sentry which is that Sentry supports a couple of different scope managers. For UI applications (like WinUI apps) Sentry uses a global scope manager - in that mode the scope stack is basically a singleton. For Server based apps (like ASP.NET Core) Sentry uses an AsyncLocal scope manager where each different AsyncLocal context has it's own scope stack... this means that things you configure on the scope for one web request won't be included as context for events that get captured by other web requests.

[munkii]

Thanks James.

Another thing we use AppCenter events for is to helko make decisions on what parts of the app need more help or work and what features should be left alone.

For instance if there is a feature that only 5% of the user base is using we should not be spending a week making changes to it as that is not a good use of our limited resources. To help make those decisions we need to be able get decent usage numbers of different features. Can we do that via breadcrumbing?

[jamescrosswell]

Hm, you might be able to use Sentry's Metrics for this.