Troubleshooting Datadog Web Identify Not Working With Flutter

Jul 29, 2025 by Sharif Sakr 62 views

Web + Identify Not Working: A Deep Dive and Solution

Hey guys! 👋 We've got a bit of a mystery on our hands today, and it revolves around getting the Datadog web integration to play nice with the identify method. It seems like some of us are experiencing an issue where, while logs are happily reporting from our web builds, the crucial @usr.id and custom parameters aren't being set when using identify. This is a problem, because those user IDs are super important for tracking unique users and sessions!

The Bug: Identify Not Setting `@usr.id` on Web

So, the main issue is that when using the identify method in our Flutter app with Datadog, it works perfectly on iOS and Android. But when we switch to the web, nada! 😭 No @usr.id, no custom parameters – just logs floating around without any user context. Let's dive into the details and see if we can crack this nut.

The Code Snippet

Here's the code snippet that highlights how we're setting the user info:

class DataDogAnalytics  {
  @override
  void identify(String id, {Map<String, Object> extraInfo = const {}}) {
    DatadogSdk.instance.setUserInfo(id: id, extraInfo: extraInfo);
  }

  @override
  void addAttribute(SessionAttribute attribute) {
    DatadogSdk.instance.rum?.addAttribute(attribute.key, attribute.value);

    DatadogSdk.instance.setUserInfo(
      extraInfo: {attribute.key: attribute.value},
    );
  }

  @override
  void track(String name, Map<String, Object?> attributes) {
    DatadogSdk.instance.rum?.addAction(RumActionType.tap, name, attributes);
  }
}

As you can see, we're using DatadogSdk.instance.setUserInfo to set the user ID and any extra info. This method is supposed to be the magic bullet, but it seems like it's misfiring on the web.

The Setup

Here are the versions and setup details we're working with:

datadog_flutter_plugin: 2.11.0
datadog_tracking_http_client: 2.3.0

And here's how we're including the Datadog browser agent in our index.html:

  <script type="text/javascript" src="https://www.datadoghq-browser-agent.com/us5/v5/datadog-logs.js"></script>
  <script type="text/javascript" src="https://www.datadoghq-browser-agent.com/us5/v5/datadog-rum-slim.js"></script>

Everything seems to be in place, but the logs from the web aren't being identified. It feels like the SDK on the web side is somehow detached from the Flutter side, like they're not communicating properly. 😕

Reproduction Steps

To reproduce this issue, you can follow these steps:

Create a web project in Flutter.
Implement the identify method with any user ID.
Add some logs to your application.
Run the app on the web and check Datadog.

You'll likely find that the logs are there, but the @usr.id is missing.

SDK Logs (or Lack Thereof)

Interestingly, even when setting the SDK verbosity to debug (DatadogSdk.instance.sdkVerbosity = CoreLoggerLevel.debug;), we're not seeing any logs from the Datadog SDK itself. This makes it even harder to diagnose the problem, as we're flying blind without any internal SDK feedback.

Expected Behavior

The expected behavior is that all logs originating from the web should have the @usr.id attribute set with the identified user ID. This is crucial for correlating user actions and events across different platforms.

Affected SDK Versions

We've confirmed that this issue affects version 2.11.0 of the Datadog Flutter plugin.

Flutter Version and Device Information

We're using Flutter version 3.29.2, and the issue is observed in web builds, specifically on Chrome.

Root Cause Analysis and Potential Solutions

Okay, so we've laid out the problem. Now, let's put on our detective hats and try to figure out what's going on. 🕵️‍♂️

The Detached SDK Theory

The main hunch here is that the Datadog SDK instances on the Flutter and web sides aren't properly linked. This could be due to a few reasons:

Initialization Issues: The web SDK might not be initialized correctly or at the right time in the lifecycle.
Context Mismatch: The user context set in the Flutter SDK might not be propagating to the web SDK.
Configuration Differences: There might be subtle differences in the configuration between the Flutter and web SDKs that are causing the disconnect.

Potential Solutions

Based on these theories, here are some potential solutions we can try:

Verify Web SDK Initialization: Double-check that the Datadog web SDK is initialized correctly in the index.html file. Make sure the API key, application ID, and environment are set correctly.
Early Initialization: Try initializing the Datadog SDK as early as possible in the Flutter app's lifecycle, even before the main widget is built. This might help ensure that the context is set up before any logs or events are generated.
Manual Context Propagation: As a workaround, we could try manually propagating the user ID to the web SDK. This might involve using JavaScript interop to call a function in the web SDK and set the user ID directly.
Configuration Consistency: Ensure that the Datadog configuration is consistent between the Flutter and web sides. Check for any discrepancies in the API key, application ID, environment, and other settings.
Check Datadog Documentation: Sometimes the most obvious solution is the one we overlook. It’s always a good idea to revisit the official Datadog documentation for Flutter and web integration to ensure we haven’t missed any crucial steps. 📚

Practical Steps and Workarounds

Let's break down these solutions into actionable steps. We'll start with the simplest ones and move towards more complex workarounds if necessary.

Step 1: Verify Web SDK Initialization

Go back to your index.html file and double-check the initialization code for the Datadog web SDK. Make sure you have the correct API key, application ID, and environment. A common mistake is to accidentally use the wrong credentials, which can prevent the SDK from working correctly.

Here’s an example of how the initialization might look:

<script>
  window.DD_RUM && window.DD_RUM.init({
    clientToken: 'YOUR_CLIENT_TOKEN',
    applicationId: 'YOUR_APPLICATION_ID',
    site: 'datadoghq.com',
    service: 'your-service-name',
    env: 'production',
    version: '1.0.0',
    sampleRate: 100,
    trackInteractions: true
  });
</script>

Step 2: Early Initialization in Flutter

In your Flutter app, try initializing the Datadog SDK as early as possible. A good place to do this is in the main function, before running the app. This can help ensure that the SDK is ready to capture user context and events from the get-go.

void main() async {
  WidgetsFlutterBinding.ensureInitialized();
  await DatadogSdk.instance.initialize(
    clientToken: 'YOUR_CLIENT_TOKEN',
    environment: 'production',
    rumConfiguration: RumConfiguration(applicationId: 'YOUR_APPLICATION_ID'),
    loggingConfiguration: LoggingConfiguration(),
  );
  runApp(MyApp());
}

Step 3: Manual Context Propagation (Workaround)

If the above steps don't work, we can try manually propagating the user ID to the web SDK using JavaScript interop. This involves calling a JavaScript function from Flutter to set the user context in the web SDK.

First, define a JavaScript function in your index.html file:

<script>
  function setDatadogUser(userId) {
    if (window.DD_RUM) {
      window.DD_RUM.setUser({ id: userId });
    }
  }
</script>

Then, in your Flutter code, use the js package to call this function:

import 'package:js/js.dart';

@JS('setDatadogUser')
external void setDatadogUser(String userId);

// ...

void identify(String id) {
  DatadogSdk.instance.setUserInfo(id: id);
  setDatadogUser(id); // Call the JavaScript function
}

This workaround can help ensure that the user context is explicitly set in the web SDK, even if the Flutter SDK isn't propagating it correctly.

Step 4: Configuration Consistency

Double-check your Datadog configuration across both the Flutter and web SDKs. Ensure that the API key, application ID, environment, and other settings are consistent. Inconsistencies in configuration can lead to unexpected behavior and prevent the SDKs from working together seamlessly.

Step 5: Consult Datadog Documentation and Support

If you've tried all the above steps and are still facing issues, it's time to dive deep into the Datadog documentation. Look for any specific instructions or troubleshooting tips related to web integration and user identification. If the documentation doesn't provide a solution, consider reaching out to Datadog support for assistance. They might have insights or solutions specific to your setup.

Conclusion: Cracking the Web Identify Mystery

Debugging these kinds of issues can be tricky, but by systematically exploring potential causes and solutions, we can usually find a way forward. The key is to break down the problem into smaller, manageable steps and test each solution individually. Hopefully, one of the solutions we've discussed will help you get your Datadog web integration working smoothly. Remember, we're all in this together, and sharing our experiences and solutions can help the entire community. 💪

Let's keep digging, keep experimenting, and keep sharing our findings. If you've encountered this issue and found a different solution, please share it in the comments below! Let's help each other out. Happy debugging, guys! 🎉