Conviva DPI Sensor Integration

Supports the traceparent header generation and collection.

More Details:

iOS Sensor Integration Help

GitHub Document

• Supports limiting the burst in reporting errors.

• Fixes the issue in collecting link clicks in multi-page applications.

• Supports setting a proxy for the Gateway URL.

More Details:

JavaScript Sensor Integration Help

GitHub Document

• Enhanced Network Request Collection: Supports automatic collection of network requests in Flutter for Dart’s core HTTP client, as well as popular libraries like Dio, Retrofit, and Chopper.

• Controlled Ingestion Feature: Now disabled by default. Upgrading to this version will not alter collection behavior unless explicitly enabled. To activate this feature, please contact the Conviva support team.

• Bug Fix: Target URL Query Parameters: Resolves an issue where the TargetURL in network requests was not reported along with query parameters.

• Bug Fix: Case Insensitivity: Fixes an issue where network request collection was failing when the TargetURL had case-insensitive variations.

More Details:

Android Sensor Integration Help

GitHub Document

Button click tracking facilitates the automatic collection of click events triggered by users while interacting with an application. It monitors a variety of clickable UI elements on the screen, including buttons, links, input fields, drop-down menus, checkboxes, radio buttons, and more. This broad coverage ensures comprehensive tracking across all standard HTML elements.

The tracker captures useful details about each clickable element, such as its type, name, ID, class, text, and value. These attributes assist in uniquely identifying the UI components and understanding user interaction metrics.

This feature provides intelligent control over event collection, rather than tracking every single click indiscriminately. It allows customized click event tracking based on specific element tags, types, IDs, and other attributes, enabling users to selectively collect click events for the elements that are most relevant to their analysis.

For more information, see platform-wise GitHub documents:

• GitHub Document for Android.

• GitHub Document for iOS.

• GitHub Document for JS(WEB).

Network request tracking allows for the monitoring and collection of network requests triggered within an application using XMLHttpRequest, along with the API response data. This includes capturing both the header and body information of requests and responses, provided certain conditions are met. This feature ensures secure and efficient tracking of network activity while adhering to privacy and performance guidelines.

• Conviva DPI sensor for the Android platform supports OKHTTP3 execute/enqueue, OKHTTP3 retrofit execute/enqueue, and HTTPURLConnection/HTTPSURLconnections.

  • Collects the request/response Body if:

    • The size is less than 10KB and the content-length is available.

    • The response body is in JSON format.

    • The content-type is one of: "json", "text/plain", "text/javascript", or "application/javascript".

    • The response type is not "opaque".

  • Collects the request/response Header if:

    • The server includes the header "Access-Control-Expose-Headers:" in the response.

    • The response type is not "opaque".

  GitHub Document for Android.

• Conviva DPI sensor for the iOS platform supports NSURLSession and NSURLConnection. The sensor does not support any requests fired from WKWebView or any Playback requests using the default AVPlayer implementation (AVPlayers spawns a new process to send all playback requests).

  GitHub Document for iOS.
  

• Conviva DPI sensors for the JS (WEB) platform supports XMLHttpRequest and fetch. The sensor also collects network request/response headers, body, and status, if the NWR includes response types other than “opaque.”

  GitHub Document for JS (Web).
  

The Screen/Page View Tracking feature enables the automatic collection of information when a user interacts with a screen, either on the first launch or during subsequent relaunches of an application. This feature ensures consistent screen or page view tracking across platforms, with options for customization and manual invocation where needed.

On the Android platform, the auto-collection of screen_view and application_install events may be temporarily affected during the initial launch after a fresh app install or a data clear. This is due to controlled ingestion by Conviva and remains in effect only until the Conviva Remote Config is available. Once available, auto-collection resumes as expected in later launches.

GitHub Document for Android.

On the iOS platform, specifically with SwiftUI, screen_view events are not auto-collected. Instead, Conviva provides extension functions that developers can use to manually trigger screen view tracking.

GitHub Document for iOS.

On the JavaScript platform, calling the trackPageView() API automatically uses document.title as the page title. Developers can override this by passing a custom title as an argument.

GitHub Document for JS (Web).

The Custom Event Tracking feature allows customers to define and track in-app events that are important to their business goals. These events may vary across the business vericals and hence not pre-defined in Conviva DPI sensor. Customers need to specify such events while setting up DPI sensor integration, allowing the sensor to capture customer-specific events relevant to application’s performance and user experience.

• To enable the Custom Event Tracking feature for Android platform, use the trackCustomEvent() API to track all kinds of events. This API provides 2 fields to describe the tracked events:

  • eventName: Name of the custom event.

  • eventData: Data in a JSONObject or a JSON-formatted String.

// Set up the event properties JSONObject
JSONObject eventDataJSON = new JSONObject();
eventDataJSON.put("identifier1", intValue);
eventDataJSON.put("identifier2", boolValue);
eventDataJSON.put("identifier3", "stringValue");

String eventName = "your-event-name";

tracker.trackCustomEvent(eventName, eventDataJSON);

GitHub Document for Android.

• To enable the Custom Event Tracking feature for iOS platform, use the two APIs to track custom events:

  Copy

  /**
   * Track custom event.
   * @param name Name of the custom event.
   * @param data A JSON-formatted string.
   */
  - (void)trackCustomEvent:(NSString *)name data:(nonnull NSString*)data;
  
  /**
   * Track custom event.
   * @param name Name of the custom event.
   * @param eventData Dictionary/Array of dictionaries.
   */
  - (void)trackCustomEvent:(NSString *)name eventData:(nonnull id)eventData;

  GitHub Document for iOS.

• To enable the Custom Event Tracking feature for JS (WEB) platform, use trackCustomEvent() API to track all kinds of events. This API provides 2 fields to describe the tracked events:

  • name: Name of the custom event. (Mandatory)

  • data: Any type of data in JSON format.

  Copy

  let custom_data = {
                      "identifier1": "test",
                      "identifier2": 1,
                      "identifier3":true
                    };
  
  window.apptracker('trackCustomEvent', {
      name: "custom_event_name",
      data: custom_data
  });

  GitHubDocument for JS (Web).

Custom Tags are global tags applied to all events and persist throughout the application lifespan, or until they are cleared.

• For the Android platform:

  • Set custom tags
    

    Copy

    // Adds the custom tags
    HashMap<String, Object> tags = new HashMap<>();
    tags.put("key1", intValue);
    tags.put("key2", boolValue);
    tags.put("key3", "stringValue");
    tracker.setCustomTags(tags);

  • Clear some custom tags
    

    Copy

    // Clears custom tags key1 & key2
    Set<String> clearTagKeysSet = new HashSet<>();
    clearTagKeysSet.add("key1");
    clearTagKeysSet.add("key2");
    tracker.clearCustomTags(clearTagKeysSet);

  • Clear all custom tags
    

    Copy

    // Clears all the custom tags
    tracker.clearAllCustomTags();

GitHub Document for Android.

• For the iOS platform:

  • Set custom tags
    

    Copy

    // Swift:
    // Adds the custom tags
    let tags = ["Key1": "Value1", "Key2": "Value2"]
    tracker?.setCustomTags(tags)
    
    --------------------------------------------------
    
    // ObjC:
    // Adds the custom tags
    NSDictionary* tags = @{
        @"Key1": @"Value1",
        @"Key2": @"Value2",
    };
    [tracker setCustomTags:tags];

  • Clear some custom tags
    

    Copy

    // Swift:
    // Clears custom tags Key1, Key2 & Key3
    let keys = ["Key1", "Key2", "Key3"]
    tracker?.clearCustomTags(keys)
    
    ---------------------------------------------------
    
    // ObjC:
    // Clears custom tags Key1, Key2 & Key3
    NSArray* keys = @[ @"Key1", @"Key2", @"Key3" ];
    [tracker clearCustomTags:keys];

  • Clear all custom tags
    

    Copy

    // Swift:
    // Clears all the custom tags
    tracker?.clearAllCustomTags()
    
    ---------------------------------------
    
    // ObjC:
    // Clears all the custom tags
    [tracker clearAllCustomTags];

  GitHub Document for iOS.

• For the JS (WEB) platform:

  • Set custom tags
    

    Copy

    import { setCustomTags } from '@convivainc/conviva-js-appanalytics';
    
    let customTagsData = { tagKey1: 'tagValue1', tagKey2: 1, tagKey3: true };
    setCustomTags(customTagsData);

  • Clear custom tags
    

    Copy

    import { unsetCustomTags } from '@convivainc/conviva-js-appanalytics';
    
    // Remove custom tags tagKey2 & tagKey3
    let customTagsData = ['tagKey2', 'tagKey3'];
    unsetCustomTags(customTagsData);

GitHub Document for JS (Web).

Conviva DPI enables efficient application error analysis to troubleshoot and resolve app errors impacting user experiences and app performance.

• Errors displayed in metric widget time series and dimensional drill-downs

  Analyze auto-collected and custom errors in metric widget time series and dimensional drill-downs, including related stack traces.

• Errors in metric and flow definitions

  Use auto-collected and custom errors (web only, trackError()) in metric and flow definitions for advance performance analytics

Web App Errors

For Web apps, Conviva DPI auto-collects the conviva_application_error event to capture uncaught run-time application issues that don’t cause app crashes, such as JavaScript exceptions and unhandled rejections/promises. Selecting the Web Errors metric, these error events appear in the Trends Web Errors metric widget time series, along with the Error Message and Stack Trace dimensions. Analyzing the Web Errors metric helps detect broken functionality due to uncaught errors especially useful for smart TVs, browsers, and web apps where silent failures impact user experiences.

Additionally, select the Web Errors metric widget and use the dimension tables to isolate error root causes across dimensions. If available, Conviva DPI sensor auto-collects the related errorReason and errorID data and display this data in dimension tables for additional analysis.

Android/iOS App Crashes

For Android and iOS apps, Conviva DPI auto-collects conviva_application_error events reported as application crashes, due segmentation faults, fatal exceptions, and other causes of native app crashes.

Selecting the App Crashes metric, these error events appear in the Trends App Crashes metric widget time series. Analyzing the App Crashes metric helps detect fatal app exceptions and resource blockage. Additionally, select the App Crashes metric widget and use the dimension tables to isolate crash related root causes, such as connection issues and under-resourced server processes.

Metrics for Crash to App Startup and Mins with Crash provide data to troubleshooting issues after which app restarted within 30 seconds. For more details, see DPI Metrics.

Note: Conviva DPI performs a best-attempt to detect and report app crashes before the app terminates. If not reported, Conviva DPI attempts to report the crash during the next app launch. In somse cases, app crashes may not be reported, such as app restart exceeding the Android uses a 20-second app restart limit.

Error Analysis in Trends Metric Widget and Dimension Tables

For web app errors, In the Trends Analysis tab select the Web Errors time series to the related error messages and stack trace data.

Selecting a specific error message creates an instant-filter to isolate related root causes across the other dimensions, such as app version. Open the stacktrace to examine the active stack frames at the time of the error.

For iOS/Android apps, in the Trends Analysis tab select the App Crashes time series to the related error messages and stack trace data.

Selecting a specific app crash error message creates an instant-filter to isolate related root causes across the other dimensions, such as app version. Open the stacktrace to examine the active stack frames at the time of the app crash.

Custom Metrics Based on Application Errors and Event Data

To support advance performance analysis, Conviva DPI supports custom metrics based on the Conviva pre-defined conviva_application_error event as the initial or complete event for use in custom metric building and flow settings.

In the Activation settings for Metric Builder or Flow settings, select the conviva_application_error event as the initial or complete event and set the tag key for any specfic error identifier, such as error number or error message.

The Semantic Mapper enables customization of the error tag key and tag values to build specific app error events for use in custom error metrics.

Examples error events for advanced performance analysis include custom metrics based on app backgrounding followed an app error or a series of user actions followed by app errors.

Note: Using Paths to identify the sequence of user actions preceeding and following app errors can help visualize the types of user behaviors and app errors to include in custom metrics.

Block Event allows you to efficiently restrict event reporting to limit ingest to the most relevant and meaningful events from the sensor, ensuring the accuracy and relevancy of your experience-centric data.

The Configure Network Request tab allows you to set collection rules for conviva_network_request events. When the rules are configured, the Conviva sensor collects events that match these rules. You can then select the collected events as raw data for mapping and metric building. The Management tab also displays all configured collection rules for review and update.

• Blocking Events

• Configuring Network Request

Blocking Events

Configuring Network Request

Block Event allows you to efficiently restrict event reporting to limit ingest to the most relevant and meaningful events from the sensor, ensuring the accuracy and relevancy of your experience-centric data.

The Configure Network Request tab allows you to set collection rules for conviva_network_request events. When the rules are configured, the Conviva sensor collects events that match these rules. You can then select the collected events as raw data for mapping and metric building. The Management tab also displays all configured collection rules for review and update.

• Blocking Events

• Configuring Network Request

Block Event allows you to efficiently restrict event reporting to limit ingest to the most relevant and meaningful events from the sensor, ensuring the accuracy and relevancy of your experience-centric data.

The Configure Network Request tab allows you to set collection rules for conviva_network_request events. When the rules are configured, the Conviva sensor collects events that match these rules. You can then select the collected events as raw data for mapping and metric building. The Management tab also displays all configured collection rules for review and update.

• Blocking Events

• Configuring Network Request