From 3677898705e23ea95a44e09e24431f88e6f149d7 Mon Sep 17 00:00:00 2001 From: Thiago Moreira Date: Thu, 24 Jul 2025 00:10:51 -0300 Subject: [PATCH 1/2] docs: add public API documentation for all members --- analysis_options.yaml | 1 + .../adapters/engine_clarity_adapter.dart | 13 ++++- .../engine_faro_analytics_adapter.dart | 11 +++++ .../engine_firebase_analytics_adapter.dart | 11 +++++ ...gine_google_logging_analytics_adapter.dart | 11 +++++ .../engine_splunk_analytics_adapter.dart | 11 +++++ .../adapters/i_engine_analytics_adapter.dart | 43 ++++++++++++++++ .../adapters/engine_crashlytics_adapter.dart | 11 +++++ .../engine_faro_bug_tracking_adapter.dart | 11 +++++ ...e_google_logging_bug_tracking_adapter.dart | 11 +++++ .../i_engine_bug_tracking_adapter.dart | 48 ++++++++++++++++++ lib/src/bug_tracking/engine_bug_tracking.dart | 49 +++++++++++++++++++ lib/src/config/engine_clarity_config.dart | 10 ++++ lib/src/config/engine_crashlytics_config.dart | 6 +++ lib/src/config/engine_faro_config.dart | 32 ++++++++++++ .../engine_firebase_analytics_config.dart | 6 +++ .../config/engine_google_logging_config.dart | 17 +++++++ .../config/engine_http_tracking_config.dart | 15 ++++++ lib/src/config/engine_splunk_config.dart | 20 ++++++++ lib/src/enums/engine_log_level_type.dart | 23 +++++++++ lib/src/http/engine_http_client.dart | 32 +++++++++++- lib/src/http/engine_http_client_request.dart | 38 +++++++++++++- lib/src/http/engine_http_override.dart | 16 ++++++ lib/src/models/engine_analytics_model.dart | 20 ++++++++ lib/src/models/engine_bug_tracking_model.dart | 14 ++++++ .../observers/engine_navigator_observer.dart | 6 +++ lib/src/session/engine_session.dart | 17 +++++++ lib/src/utils/engine_util.dart | 10 ++++ lib/src/widgets/engine_mask_widget.dart | 8 +++ lib/src/widgets/engine_stateful_widget.dart | 38 ++++++++++++++ lib/src/widgets/engine_stateless_widget.dart | 3 ++ lib/src/widgets/engine_widget.dart | 4 ++ 32 files changed, 562 insertions(+), 4 deletions(-) diff --git a/analysis_options.yaml b/analysis_options.yaml index cb2f0e1..0a70502 100644 --- a/analysis_options.yaml +++ b/analysis_options.yaml @@ -50,6 +50,7 @@ analyzer: linter: rules: + public_member_api_docs: true # === SECURITY & SAFETY (2025 Critical) === # Modern security practices avoid_dynamic_calls: false diff --git a/lib/src/analytics/adapters/engine_clarity_adapter.dart b/lib/src/analytics/adapters/engine_clarity_adapter.dart index ad5c071..802707c 100644 --- a/lib/src/analytics/adapters/engine_clarity_adapter.dart +++ b/lib/src/analytics/adapters/engine_clarity_adapter.dart @@ -2,23 +2,32 @@ import 'package:clarity_flutter/clarity_flutter.dart'; import 'package:engine_tracking/engine_tracking.dart'; import 'package:flutter/widgets.dart'; +/// Microsoft Clarity analytics adapter for the Engine Tracking library. +/// +/// Provides integration with Microsoft Clarity for session recording, +/// heatmaps, and user behavior analytics. class EngineClarityAdapter implements IEngineAnalyticsAdapter { + /// Creates a new Microsoft Clarity analytics adapter. + /// + /// [config] - The Microsoft Clarity configuration. EngineClarityAdapter(this.config); + /// The Microsoft Clarity configuration. @override final EngineClarityConfig config; + /// The name of this adapter. @override String get adapterName => 'Microsoft Clarity'; + /// Whether this adapter is enabled. @override bool get isEnabled => config.enabled; + /// Whether this adapter has been initialized. @override bool get isInitialized => _isInitialized; - bool get isFaroInitialized => isEnabled && _isInitialized; - bool _isInitialized = false; @override diff --git a/lib/src/analytics/adapters/engine_faro_analytics_adapter.dart b/lib/src/analytics/adapters/engine_faro_analytics_adapter.dart index 8943566..793b3dd 100644 --- a/lib/src/analytics/adapters/engine_faro_analytics_adapter.dart +++ b/lib/src/analytics/adapters/engine_faro_analytics_adapter.dart @@ -2,23 +2,34 @@ import 'package:engine_tracking/engine_tracking.dart'; import 'package:faro/faro.dart'; import 'package:flutter/widgets.dart'; +/// Grafana Faro analytics adapter for the Engine Tracking library. +/// +/// Provides integration with Grafana Faro for observability and analytics. class EngineFaroAnalyticsAdapter implements IEngineAnalyticsAdapter { + /// Creates a new Grafana Faro analytics adapter. + /// + /// [config] - The Grafana Faro configuration. EngineFaroAnalyticsAdapter(this.config); + /// The Grafana Faro configuration. @override final EngineFaroConfig config; + /// The name of this adapter. @override String get adapterName => 'Grafana Faro'; + /// Whether this adapter is enabled. @override bool get isEnabled => config.enabled; + /// Whether this adapter has been initialized. @override bool get isInitialized => _isInitialized; bool _isInitialized = false; + /// Whether Grafana Faro is initialized and ready. bool get isFaroInitialized => isEnabled && _isInitialized && _faro != null; Faro? _faro; diff --git a/lib/src/analytics/adapters/engine_firebase_analytics_adapter.dart b/lib/src/analytics/adapters/engine_firebase_analytics_adapter.dart index 9286c78..be79261 100644 --- a/lib/src/analytics/adapters/engine_firebase_analytics_adapter.dart +++ b/lib/src/analytics/adapters/engine_firebase_analytics_adapter.dart @@ -2,21 +2,32 @@ import 'package:engine_tracking/engine_tracking.dart'; import 'package:firebase_analytics/firebase_analytics.dart'; import 'package:flutter/material.dart'; +/// Firebase Analytics adapter for the Engine Tracking library. +/// +/// Provides integration with Firebase Analytics for event tracking and user analytics. class EngineFirebaseAnalyticsAdapter implements IEngineAnalyticsAdapter { + /// Creates a new Firebase Analytics adapter. + /// + /// [config] - The Firebase Analytics configuration. EngineFirebaseAnalyticsAdapter(this.config); + /// The Firebase Analytics configuration. @override final EngineFirebaseAnalyticsConfig config; + /// The name of this adapter. @override String get adapterName => 'Firebase Analytics'; + /// Whether this adapter is enabled. @override bool get isEnabled => config.enabled; + /// Whether this adapter has been initialized. @override bool get isInitialized => _isInitialized; + /// Whether Firebase Analytics is initialized and ready. bool get isFirebaseAnalyticsInitialized => isEnabled && _isInitialized && _firebaseAnalytics != null; bool _isInitialized = false; diff --git a/lib/src/analytics/adapters/engine_google_logging_analytics_adapter.dart b/lib/src/analytics/adapters/engine_google_logging_analytics_adapter.dart index 30e523b..8894549 100644 --- a/lib/src/analytics/adapters/engine_google_logging_analytics_adapter.dart +++ b/lib/src/analytics/adapters/engine_google_logging_analytics_adapter.dart @@ -3,21 +3,32 @@ import 'package:flutter/material.dart'; import 'package:googleapis/logging/v2.dart' as logging; import 'package:googleapis_auth/auth_io.dart' as auth; +/// Google Cloud Logging analytics adapter for the Engine Tracking library. +/// +/// Provides integration with Google Cloud Logging for analytics event tracking. class EngineGoogleLoggingAnalyticsAdapter implements IEngineAnalyticsAdapter { + /// Creates a new Google Cloud Logging analytics adapter. + /// + /// [config] - The Google Cloud Logging configuration. EngineGoogleLoggingAnalyticsAdapter(this.config); + /// The Google Cloud Logging configuration. @override final EngineGoogleLoggingConfig config; + /// The name of this adapter. @override String get adapterName => 'Google Cloud Logging Analytics'; + /// Whether this adapter is enabled. @override bool get isEnabled => config.enabled; + /// Whether this adapter has been initialized. @override bool get isInitialized => _isInitialized; + /// Whether Google Cloud Logging Analytics is initialized and ready. bool get isGoogleLoggingAnalyticsInitialized => isEnabled && _isInitialized; bool _isInitialized = false; diff --git a/lib/src/analytics/adapters/engine_splunk_analytics_adapter.dart b/lib/src/analytics/adapters/engine_splunk_analytics_adapter.dart index c792f4d..569736a 100644 --- a/lib/src/analytics/adapters/engine_splunk_analytics_adapter.dart +++ b/lib/src/analytics/adapters/engine_splunk_analytics_adapter.dart @@ -5,21 +5,32 @@ import 'package:engine_tracking/src/analytics/adapters/i_engine_analytics_adapte import 'package:engine_tracking/src/config/engine_splunk_config.dart'; import 'package:flutter/material.dart'; +/// Splunk analytics adapter for the Engine Tracking library. +/// +/// Provides integration with Splunk for analytics event tracking and logging. class EngineSplunkAnalyticsAdapter implements IEngineAnalyticsAdapter { + /// Creates a new Splunk analytics adapter. + /// + /// [config] - The Splunk configuration. EngineSplunkAnalyticsAdapter(this.config); + /// The Splunk configuration. @override final EngineSplunkConfig config; + /// The name of this adapter. @override String get adapterName => 'Splunk'; + /// Whether this adapter is enabled. @override bool get isEnabled => config.enabled; + /// Whether this adapter has been initialized. @override bool get isInitialized => _isInitialized; + /// Whether Splunk is initialized and ready. bool get isSplunkInitialized => isEnabled && _isInitialized; bool _isInitialized = false; diff --git a/lib/src/analytics/adapters/i_engine_analytics_adapter.dart b/lib/src/analytics/adapters/i_engine_analytics_adapter.dart index 67804f4..aea6b48 100644 --- a/lib/src/analytics/adapters/i_engine_analytics_adapter.dart +++ b/lib/src/analytics/adapters/i_engine_analytics_adapter.dart @@ -1,18 +1,61 @@ import 'package:engine_tracking/src/config/config.dart'; +/// Interface for analytics adapters in the Engine Tracking library. +/// +/// Defines the contract that all analytics adapters must implement +/// to provide consistent analytics functionality across different services. +/// +/// [TConfig] - The configuration type for this adapter. abstract class IEngineAnalyticsAdapter { + /// The name of this adapter. String get adapterName; + + /// Whether this adapter is enabled. bool get isEnabled; + + /// Whether this adapter has been initialized. bool get isInitialized; + + /// The configuration for this adapter. TConfig get config; + /// Initializes this adapter. Future initialize(); + + /// Disposes of this adapter and cleans up resources. Future dispose(); + /// Logs an analytics event. + /// + /// [name] - The name of the event. + /// [parameters] - Optional parameters for the event. Future logEvent(final String name, [final Map? parameters]); + + /// Sets the user ID and optional user information. + /// + /// [userId] - The user ID. + /// [email] - Optional email address. + /// [name] - Optional display name. Future setUserId(final String? userId, [final String? email, final String? name]); + + /// Sets a user property. + /// + /// [name] - The property name. + /// [value] - The property value. Future setUserProperty(final String name, final String? value); + + /// Sets the current page/screen. + /// + /// [screenName] - The screen name. + /// [previousScreen] - Optional previous screen name. + /// [parameters] - Optional page parameters. Future setPage(final String screenName, [final String? previousScreen, final Map? parameters]); + + /// Logs an app open event. + /// + /// [parameters] - Optional parameters for the event. Future logAppOpen([final Map? parameters]); + + /// Resets this adapter to its initial state. Future reset(); } diff --git a/lib/src/bug_tracking/adapters/engine_crashlytics_adapter.dart b/lib/src/bug_tracking/adapters/engine_crashlytics_adapter.dart index 4ca1be9..6e748ed 100644 --- a/lib/src/bug_tracking/adapters/engine_crashlytics_adapter.dart +++ b/lib/src/bug_tracking/adapters/engine_crashlytics_adapter.dart @@ -3,21 +3,32 @@ import 'package:engine_tracking/src/config/engine_crashlytics_config.dart'; import 'package:firebase_crashlytics/firebase_crashlytics.dart'; import 'package:flutter/foundation.dart'; +/// Firebase Crashlytics adapter for the Engine Tracking library. +/// +/// Provides integration with Firebase Crashlytics for crash reporting and error tracking. class EngineCrashlyticsAdapter implements IEngineBugTrackingAdapter { + /// Creates a new Firebase Crashlytics adapter. + /// + /// [config] - The Firebase Crashlytics configuration. EngineCrashlyticsAdapter(this.config); + /// The name of this adapter. @override String get adapterName => 'Firebase Crashlytics'; + /// Whether this adapter is enabled. @override bool get isEnabled => config.enabled; + /// Whether this adapter has been initialized. @override bool get isInitialized => _isInitialized; + /// The Firebase Crashlytics configuration. @override final EngineCrashlyticsConfig config; + /// Whether Firebase Crashlytics is initialized and ready. bool get isCrashlyticsInitialized => isEnabled && _isInitialized && _crashlytics != null; bool _isInitialized = false; diff --git a/lib/src/bug_tracking/adapters/engine_faro_bug_tracking_adapter.dart b/lib/src/bug_tracking/adapters/engine_faro_bug_tracking_adapter.dart index ff3dd70..5a7e001 100644 --- a/lib/src/bug_tracking/adapters/engine_faro_bug_tracking_adapter.dart +++ b/lib/src/bug_tracking/adapters/engine_faro_bug_tracking_adapter.dart @@ -4,22 +4,33 @@ import 'package:engine_tracking/engine_tracking.dart'; import 'package:faro/faro.dart'; import 'package:flutter/foundation.dart'; +/// Grafana Faro bug tracking adapter for the Engine Tracking library. +/// +/// Provides integration with Grafana Faro for error tracking and crash reporting. class EngineFaroBugTrackingAdapter implements IEngineBugTrackingAdapter { + /// Creates a new Grafana Faro bug tracking adapter. + /// + /// [config] - The Grafana Faro configuration. EngineFaroBugTrackingAdapter(this.config); + /// The name of this adapter. @override String get adapterName => 'Grafana Faro Bug Tracking'; + /// Whether this adapter is enabled. @override bool get isEnabled => config.enabled; + /// Whether this adapter has been initialized. @override bool get isInitialized => _isInitialized; + /// Whether Grafana Faro is initialized and ready. bool get isFaroInitialized => isEnabled && _isInitialized && _faro != null; bool _isInitialized = false; + /// The Grafana Faro configuration. @override final EngineFaroConfig config; diff --git a/lib/src/bug_tracking/adapters/engine_google_logging_bug_tracking_adapter.dart b/lib/src/bug_tracking/adapters/engine_google_logging_bug_tracking_adapter.dart index 0eb6c87..6e00e8f 100644 --- a/lib/src/bug_tracking/adapters/engine_google_logging_bug_tracking_adapter.dart +++ b/lib/src/bug_tracking/adapters/engine_google_logging_bug_tracking_adapter.dart @@ -4,23 +4,34 @@ import 'package:flutter/foundation.dart'; import 'package:googleapis/logging/v2.dart' as logging; import 'package:googleapis_auth/auth_io.dart' as auth; +/// Google Cloud Logging bug tracking adapter for the Engine Tracking library. +/// +/// Provides integration with Google Cloud Logging for error tracking and logging. class EngineGoogleLoggingBugTrackingAdapter implements IEngineBugTrackingAdapter { + /// Creates a new Google Cloud Logging bug tracking adapter. + /// + /// [config] - The Google Cloud Logging configuration. EngineGoogleLoggingBugTrackingAdapter(this.config); bool _isInitialized = false; + /// The name of this adapter. @override String get adapterName => 'Google Cloud Logging Bug Tracking'; + /// Whether this adapter is enabled. @override bool get isEnabled => config.enabled; + /// Whether this adapter has been initialized. @override bool get isInitialized => _isInitialized; + /// The Google Cloud Logging configuration. @override final EngineGoogleLoggingConfig config; + /// Whether Google Cloud Logging Bug Tracking is initialized and ready. bool get isGoogleLoggingBugTrackingInitialized => isEnabled && _isInitialized; late final logging.LoggingApi _loggingApi; diff --git a/lib/src/bug_tracking/adapters/i_engine_bug_tracking_adapter.dart b/lib/src/bug_tracking/adapters/i_engine_bug_tracking_adapter.dart index d4287a7..9c929c8 100644 --- a/lib/src/bug_tracking/adapters/i_engine_bug_tracking_adapter.dart +++ b/lib/src/bug_tracking/adapters/i_engine_bug_tracking_adapter.dart @@ -1,23 +1,65 @@ import 'package:engine_tracking/src/config/config.dart'; import 'package:flutter/foundation.dart'; +/// Interface for bug tracking adapters in the Engine Tracking library. +/// +/// Defines the contract that all bug tracking adapters must implement +/// to provide consistent error tracking and crash reporting functionality. +/// +/// [TConfig] - The configuration type for this adapter. abstract class IEngineBugTrackingAdapter { + /// The name of this adapter. String get adapterName; + + /// Whether this adapter is enabled. bool get isEnabled; + + /// Whether this adapter has been initialized. bool get isInitialized; + + /// The configuration for this adapter. TConfig get config; + /// Initializes this adapter. Future initialize(); + + /// Disposes of this adapter and cleans up resources. Future dispose(); + /// Sets a custom key for error context. + /// + /// [key] - The key name. + /// [value] - The key value. Future setCustomKey(final String key, final Object value); + + /// Sets the user identifier for error tracking. + /// + /// [id] - The user ID. + /// [email] - The user email. + /// [name] - The user name. Future setUserIdentifier(final String id, final String email, final String name); + + /// Logs a message for debugging purposes. + /// + /// [message] - The message to log. + /// [level] - Optional log level. + /// [attributes] - Optional attributes to include. + /// [stackTrace] - Optional stack trace. Future log( final String message, { final String? level, final Map? attributes, final StackTrace? stackTrace, }); + + /// Records an error with optional context. + /// + /// [exception] - The exception to record. + /// [stackTrace] - Optional stack trace. + /// [reason] - Optional reason for the error. + /// [information] - Optional additional information. + /// [isFatal] - Whether this is a fatal error. + /// [data] - Optional additional data. Future recordError( final dynamic exception, final StackTrace? stackTrace, { @@ -26,6 +68,12 @@ abstract class IEngineBugTrackingAdapter { final bool isFatal = false, final Map? data, }); + + /// Records a Flutter error. + /// + /// [errorDetails] - The Flutter error details. Future recordFlutterError(final FlutterErrorDetails errorDetails); + + /// Tests crash reporting functionality. Future testCrash(); } diff --git a/lib/src/bug_tracking/engine_bug_tracking.dart b/lib/src/bug_tracking/engine_bug_tracking.dart index 7af386c..9020b1a 100644 --- a/lib/src/bug_tracking/engine_bug_tracking.dart +++ b/lib/src/bug_tracking/engine_bug_tracking.dart @@ -150,11 +150,22 @@ class EngineBugTracking { _isInitialized = false; } + /// Resets the bug tracking system to its initial state + /// + /// This method clears all adapters and resets the initialization flag. + /// Use this to completely reset the bug tracking system. static void reset() { _adapters.clear(); _isInitialized = false; } + /// Sets a custom key-value pair for bug tracking across all adapters + /// + /// This method allows setting custom metadata that will be included + /// in crash reports and error logs across all configured bug tracking adapters. + /// + /// [key] The custom key to set + /// [value] The value associated with the key static Future setCustomKey(final String key, final Object value) async { if (!isEnabled || !_isInitialized) { return; @@ -164,6 +175,14 @@ class EngineBugTracking { await Future.wait(setCustomKeys); } + /// Sets user identification information across all bug tracking adapters + /// + /// This method allows associating user information with crash reports + /// and error logs across all configured bug tracking adapters. + /// + /// [id] The user identifier + /// [email] The user email address + /// [name] The user display name static Future setUserIdentifier(final String id, final String email, final String name) async { if (!isEnabled || !_isInitialized) { return; @@ -173,6 +192,15 @@ class EngineBugTracking { await Future.wait(setUserIdentifiers); } + /// Logs a message across all bug tracking adapters + /// + /// This method sends a log message to all configured bug tracking adapters + /// with optional level, attributes, and stack trace information. + /// + /// [message] The message to log + /// [level] Optional log level (e.g., 'info', 'warning', 'error') + /// [attributes] Optional key-value pairs to include with the log + /// [stackTrace] Optional stack trace to include with the log static Future log( final String message, { final String? level, @@ -194,6 +222,17 @@ class EngineBugTracking { await Future.wait(logs); } + /// Records an error across all bug tracking adapters + /// + /// This method records an exception with optional metadata across all + /// configured bug tracking adapters for crash reporting and error analysis. + /// + /// [exception] The exception to record + /// [stackTrace] Optional stack trace associated with the exception + /// [reason] Optional reason for the error + /// [information] Optional additional information about the error + /// [isFatal] Whether this error is considered fatal + /// [data] Optional additional data to include with the error static Future recordError( final dynamic exception, final StackTrace? stackTrace, { @@ -221,6 +260,12 @@ class EngineBugTracking { await Future.wait(errors); } + /// Records a Flutter error across all bug tracking adapters + /// + /// This method records Flutter-specific error details across all + /// configured bug tracking adapters for crash reporting and error analysis. + /// + /// [errorDetails] The Flutter error details to record static Future recordFlutterError(final FlutterErrorDetails errorDetails) async { if (!isEnabled || !_isInitialized) { return; @@ -234,6 +279,10 @@ class EngineBugTracking { await Future.wait(erros); } + /// Triggers a test crash across all bug tracking adapters + /// + /// This method is used for testing crash reporting functionality + /// across all configured bug tracking adapters. static Future testCrash() async { if (!isEnabled || !_isInitialized) { return; diff --git a/lib/src/config/engine_clarity_config.dart b/lib/src/config/engine_clarity_config.dart index d7acdbd..5bbdd2a 100644 --- a/lib/src/config/engine_clarity_config.dart +++ b/lib/src/config/engine_clarity_config.dart @@ -1,15 +1,25 @@ import 'package:engine_tracking/src/config/config.dart'; import 'package:engine_tracking/src/enums/enums.dart'; +/// Configuration for Microsoft Clarity analytics integration. +/// +/// Provides settings for Microsoft Clarity session recording and analytics. class EngineClarityConfig extends IEngineConfig { + /// Creates a new Microsoft Clarity configuration. + /// + /// [enabled] - Whether Microsoft Clarity is enabled. + /// [projectId] - The Microsoft Clarity project ID. + /// [level] - The logging level for Microsoft Clarity. EngineClarityConfig({ required super.enabled, required this.projectId, this.level = EngineLogLevelType.info, }); + /// The Microsoft Clarity project ID. final String projectId; + /// The logging level for Microsoft Clarity. final EngineLogLevelType level; @override diff --git a/lib/src/config/engine_crashlytics_config.dart b/lib/src/config/engine_crashlytics_config.dart index 1b2e2fb..d732293 100644 --- a/lib/src/config/engine_crashlytics_config.dart +++ b/lib/src/config/engine_crashlytics_config.dart @@ -1,6 +1,12 @@ import 'package:engine_tracking/src/config/config.dart'; +/// Configuration for Firebase Crashlytics integration. +/// +/// Provides settings for Firebase Crashlytics crash reporting. class EngineCrashlyticsConfig extends IEngineConfig { + /// Creates a new Firebase Crashlytics configuration. + /// + /// [enabled] - Whether Firebase Crashlytics is enabled. EngineCrashlyticsConfig({required super.enabled}); @override diff --git a/lib/src/config/engine_faro_config.dart b/lib/src/config/engine_faro_config.dart index 791caa0..1b91a49 100644 --- a/lib/src/config/engine_faro_config.dart +++ b/lib/src/config/engine_faro_config.dart @@ -2,7 +2,22 @@ import 'dart:io'; import 'package:engine_tracking/src/config/config.dart'; +/// Configuration for Grafana Faro integration. +/// +/// Provides settings for Grafana Faro observability and analytics. class EngineFaroConfig extends IEngineConfig { + /// Creates a new Grafana Faro configuration. + /// + /// [enabled] - Whether Grafana Faro is enabled. + /// [endpoint] - The Grafana Faro endpoint URL. + /// [appName] - The application name. + /// [appVersion] - The application version. + /// [environment] - The environment name. + /// [apiKey] - The Grafana Faro API key. + /// [namespace] - The namespace for events. + /// [platform] - The platform identifier. + /// [httpTrackingEnable] - Whether to enable HTTP tracking. + /// [httpOverrides] - Optional HTTP overrides for tracking. EngineFaroConfig({ required super.enabled, required this.endpoint, @@ -16,14 +31,31 @@ class EngineFaroConfig extends IEngineConfig { this.httpOverrides, }); + /// The Grafana Faro endpoint URL. final String endpoint; + + /// The application name. final String appName; + + /// The application version. final String appVersion; + + /// The environment name. final String environment; + + /// The Grafana Faro API key. final String apiKey; + + /// The namespace for events. final String namespace; + + /// The platform identifier. final String platform; + + /// Optional HTTP overrides for tracking. final HttpOverrides? httpOverrides; + + /// Whether to enable HTTP tracking. final bool httpTrackingEnable; @override diff --git a/lib/src/config/engine_firebase_analytics_config.dart b/lib/src/config/engine_firebase_analytics_config.dart index b1d4966..ea77aa9 100644 --- a/lib/src/config/engine_firebase_analytics_config.dart +++ b/lib/src/config/engine_firebase_analytics_config.dart @@ -1,6 +1,12 @@ import 'package:engine_tracking/src/config/config.dart'; +/// Configuration for Firebase Analytics integration. +/// +/// Provides settings for Firebase Analytics event tracking. class EngineFirebaseAnalyticsConfig extends IEngineConfig { + /// Creates a new Firebase Analytics configuration. + /// + /// [enabled] - Whether Firebase Analytics is enabled. EngineFirebaseAnalyticsConfig({required super.enabled}); @override diff --git a/lib/src/config/engine_google_logging_config.dart b/lib/src/config/engine_google_logging_config.dart index 5557f87..94bb989 100644 --- a/lib/src/config/engine_google_logging_config.dart +++ b/lib/src/config/engine_google_logging_config.dart @@ -1,6 +1,16 @@ import 'package:engine_tracking/src/config/config.dart'; +/// Configuration for Google Cloud Logging integration. +/// +/// Provides settings for Google Cloud Logging analytics and bug tracking. class EngineGoogleLoggingConfig extends IEngineConfig { + /// Creates a new Google Cloud Logging configuration. + /// + /// [enabled] - Whether Google Cloud Logging is enabled. + /// [projectId] - The Google Cloud project ID. + /// [logName] - The log name. + /// [credentials] - The service account credentials as a map. + /// [resource] - Optional monitored resource configuration. EngineGoogleLoggingConfig({ required super.enabled, required this.projectId, @@ -9,9 +19,16 @@ class EngineGoogleLoggingConfig extends IEngineConfig { this.resource, }); + /// The Google Cloud project ID. final String projectId; + + /// The log name. final String logName; + + /// The service account credentials as a map. final Map credentials; + + /// Optional monitored resource configuration. final Map? resource; @override diff --git a/lib/src/config/engine_http_tracking_config.dart b/lib/src/config/engine_http_tracking_config.dart index 5c03994..efe427b 100644 --- a/lib/src/config/engine_http_tracking_config.dart +++ b/lib/src/config/engine_http_tracking_config.dart @@ -2,11 +2,26 @@ import 'dart:io'; import 'package:engine_tracking/src/config/config.dart'; +/// Configuration class for Engine HTTP tracking +/// +/// This class defines the configuration options for HTTP request/response logging +/// using the EngineHttpOverride system. /// Configuration class for Engine HTTP tracking /// /// This class defines the configuration options for HTTP request/response logging /// using the EngineHttpOverride system. class EngineHttpTrackingConfig extends IEngineConfig { + /// Creates a new HTTP tracking configuration + /// + /// [enabled] Whether HTTP tracking is enabled + /// [enableRequestLogging] Whether to log HTTP requests + /// [enableResponseLogging] Whether to log HTTP responses + /// [enableTimingLogging] Whether to log request/response timing + /// [enableHeaderLogging] Whether to log request/response headers + /// [enableBodyLogging] Whether to log request/response body + /// [maxBodyLogLength] Maximum length of body content to log + /// [logName] Custom log name for HTTP tracking logs + /// [baseOverride] Optional base HttpOverrides to chain with EngineHttpTrackingConfig({ super.enabled = true, this.enableRequestLogging = true, diff --git a/lib/src/config/engine_splunk_config.dart b/lib/src/config/engine_splunk_config.dart index 827fe02..557951f 100644 --- a/lib/src/config/engine_splunk_config.dart +++ b/lib/src/config/engine_splunk_config.dart @@ -1,6 +1,17 @@ import 'package:engine_tracking/src/config/config.dart'; +/// Configuration for Splunk integration. +/// +/// Provides settings for Splunk analytics and bug tracking. class EngineSplunkConfig extends IEngineConfig { + /// Creates a new Splunk configuration. + /// + /// [enabled] - Whether Splunk is enabled. + /// [endpoint] - The Splunk HTTP Event Collector endpoint. + /// [token] - The Splunk authentication token. + /// [source] - The Splunk source name. + /// [sourcetype] - The Splunk source type. + /// [index] - The Splunk index name. EngineSplunkConfig({ required super.enabled, required this.endpoint, @@ -10,10 +21,19 @@ class EngineSplunkConfig extends IEngineConfig { required this.index, }); + /// The Splunk HTTP Event Collector endpoint. final String endpoint; + + /// The Splunk authentication token. final String token; + + /// The Splunk source name. final String source; + + /// The Splunk source type. final String sourcetype; + + /// The Splunk index name. final String index; @override diff --git a/lib/src/enums/engine_log_level_type.dart b/lib/src/enums/engine_log_level_type.dart index c8f6d5d..6f6283e 100644 --- a/lib/src/enums/engine_log_level_type.dart +++ b/lib/src/enums/engine_log_level_type.dart @@ -1,19 +1,42 @@ +/// Log level types for Engine Tracking logging and analytics. +/// +/// Defines the severity of log messages and events. enum EngineLogLevelType { + /// No logging. none('NONE', 0), + + /// Debug level logging. debug('DEBUG', 100), + + /// Informational logging. info('INFO', 800), + + /// Warning level logging. warning('WARNING', 900), + + /// Error level logging. error('ERROR', 1000), + + /// Fatal error logging. fatal('FATAL', 1200), + + /// Verbose logging. verbose('VERBOSE', 1600); + /// Creates a new log level type. const EngineLogLevelType(this.name, this.value); + + /// Creates a log level type from its name. factory EngineLogLevelType.fromName(final String name) => EngineLogLevelType.values.firstWhere((final e) => e.name == name, orElse: () => EngineLogLevelType.debug); + /// Creates a log level type from its value. factory EngineLogLevelType.fromValue(final int value) => EngineLogLevelType.values.firstWhere((final e) => e.value == value, orElse: () => EngineLogLevelType.debug); + /// The name of the log level. final String name; + + /// The numeric value of the log level. final int value; } diff --git a/lib/src/http/engine_http_client.dart b/lib/src/http/engine_http_client.dart index f4abc71..908e29f 100644 --- a/lib/src/http/engine_http_client.dart +++ b/lib/src/http/engine_http_client.dart @@ -2,8 +2,21 @@ import 'dart:io'; import 'package:engine_tracking/src/http/engine_http_client_request.dart'; -/// Internal HTTP client wrapper that handles the actual logging +/// HTTP client wrapper for Engine Tracking HTTP logging. +/// +/// Wraps a [HttpClient] and intercepts requests for logging and tracking. class EngineHttpClient implements HttpClient { + /// Creates a new Engine HTTP client. + /// + /// [_inner] - The inner [HttpClient] to wrap. + /// [enableRequestLogging] - Whether to log requests. + /// [enableResponseLogging] - Whether to log responses. + /// [enableTimingLogging] - Whether to log timing. + /// [enableHeaderLogging] - Whether to log headers. + /// [enableBodyLogging] - Whether to log bodies. + /// [maxBodyLogLength] - Maximum body length to log. + /// [logName] - Log name for tracking. + /// [ignoreDomains] - List of domains to ignore. EngineHttpClient( this._inner, { required this.enableRequestLogging, @@ -16,14 +29,31 @@ class EngineHttpClient implements HttpClient { required this.ignoreDomains, }); + /// The inner [HttpClient] instance. final HttpClient _inner; + + /// Whether to log HTTP requests. final bool enableRequestLogging; + + /// Whether to log HTTP responses. final bool enableResponseLogging; + + /// Whether to log request/response timing. final bool enableTimingLogging; + + /// Whether to log request/response headers. final bool enableHeaderLogging; + + /// Whether to log request/response bodies. final bool enableBodyLogging; + + /// Maximum length of body content to log. final int maxBodyLogLength; + + /// Log name for HTTP tracking logs. final String logName; + + /// List of domains to ignore for logging. final List ignoreDomains; @override diff --git a/lib/src/http/engine_http_client_request.dart b/lib/src/http/engine_http_client_request.dart index 4e99e71..d8b6cc7 100644 --- a/lib/src/http/engine_http_client_request.dart +++ b/lib/src/http/engine_http_client_request.dart @@ -4,8 +4,23 @@ import 'dart:io'; import 'package:engine_tracking/engine_tracking.dart'; -/// Internal HTTP request wrapper that handles logging +/// HTTP request wrapper for Engine Tracking HTTP logging. +/// +/// Wraps a [HttpClientRequest] and intercepts requests for logging and tracking. class EngineHttpClientRequest implements HttpClientRequest { + /// Creates a new Engine HTTP client request. + /// + /// [_inner] - The inner [HttpClientRequest] to wrap. + /// [method] - HTTP method. + /// [uri] - Request URI. + /// [enableRequestLogging] - Whether to log requests. + /// [enableResponseLogging] - Whether to log responses. + /// [enableTimingLogging] - Whether to log timing. + /// [enableHeaderLogging] - Whether to log headers. + /// [enableBodyLogging] - Whether to log bodies. + /// [maxBodyLogLength] - Maximum body length to log. + /// [logName] - Log name for tracking. + /// [ignoreDomains] - List of domains to ignore. EngineHttpClientRequest( this._inner, { required this.method, @@ -23,18 +38,39 @@ class EngineHttpClientRequest implements HttpClientRequest { unawaited(_logRequest()); } + /// The inner [HttpClientRequest] instance. final HttpClientRequest _inner; + + /// HTTP method. @override final String method; + + /// Request URI. @override final Uri uri; + + /// Whether to log HTTP requests. final bool enableRequestLogging; + + /// Whether to log HTTP responses. final bool enableResponseLogging; + + /// Whether to log request/response timing. final bool enableTimingLogging; + + /// Whether to log request/response headers. final bool enableHeaderLogging; + + /// Whether to log request/response bodies. final bool enableBodyLogging; + + /// Maximum length of body content to log. final int maxBodyLogLength; + + /// Log name for HTTP tracking logs. final String logName; + + /// List of domains to ignore for logging. final List ignoreDomains; late final DateTime _startTime; diff --git a/lib/src/http/engine_http_override.dart b/lib/src/http/engine_http_override.dart index 1fdaf8d..20e7623 100644 --- a/lib/src/http/engine_http_override.dart +++ b/lib/src/http/engine_http_override.dart @@ -2,12 +2,28 @@ import 'dart:io'; import 'package:engine_tracking/src/http/engine_http_client.dart'; +/// Custom HTTP override that logs HTTP requests using EngineLog.debug +/// +/// This class extends HttpOverrides to intercept HTTP requests and log them +/// using the Engine Tracking logging system. It provides detailed logging +/// of request/response data including timing, status codes, and headers. /// Custom HTTP override that logs HTTP requests using EngineLog.debug /// /// This class extends HttpOverrides to intercept HTTP requests and log them /// using the Engine Tracking logging system. It provides detailed logging /// of request/response data including timing, status codes, and headers. class EngineHttpOverride extends HttpOverrides { + /// Creates a new HTTP override for logging + /// + /// [enableRequestLogging] Whether to log HTTP requests + /// [enableResponseLogging] Whether to log HTTP responses + /// [enableTimingLogging] Whether to log request/response timing + /// [enableHeaderLogging] Whether to log request/response headers + /// [enableBodyLogging] Whether to log request/response body + /// [maxBodyLogLength] Maximum length of body content to log + /// [logName] Custom log name for HTTP tracking logs + /// [ignoreDomains] List of domains to ignore in logging + /// [existingOverrides] Optional existing Overrides to chain with EngineHttpOverride({ this.enableRequestLogging = true, this.enableResponseLogging = true, diff --git a/lib/src/models/engine_analytics_model.dart b/lib/src/models/engine_analytics_model.dart index b24f8f7..6e50e20 100644 --- a/lib/src/models/engine_analytics_model.dart +++ b/lib/src/models/engine_analytics_model.dart @@ -4,7 +4,17 @@ import 'package:engine_tracking/src/config/engine_firebase_analytics_config.dart import 'package:engine_tracking/src/config/engine_google_logging_config.dart'; import 'package:engine_tracking/src/config/engine_splunk_config.dart'; +/// Model for analytics configuration in Engine Tracking. +/// +/// Aggregates all analytics service configurations. class EngineAnalyticsModel { + /// Creates a new analytics model. + /// + /// [clarityConfig] - Microsoft Clarity configuration. + /// [firebaseAnalyticsConfig] - Firebase Analytics configuration. + /// [faroConfig] - Grafana Faro configuration. + /// [googleLoggingConfig] - Google Cloud Logging configuration. + /// [splunkConfig] - Splunk configuration. EngineAnalyticsModel({ required this.clarityConfig, required this.firebaseAnalyticsConfig, @@ -13,10 +23,19 @@ class EngineAnalyticsModel { required this.splunkConfig, }); + /// Microsoft Clarity configuration. final EngineClarityConfig? clarityConfig; + + /// Firebase Analytics configuration. final EngineFirebaseAnalyticsConfig? firebaseAnalyticsConfig; + + /// Grafana Faro configuration. final EngineFaroConfig? faroConfig; + + /// Google Cloud Logging configuration. final EngineGoogleLoggingConfig? googleLoggingConfig; + + /// Splunk configuration. final EngineSplunkConfig? splunkConfig; @override @@ -24,6 +43,7 @@ class EngineAnalyticsModel { 'EngineAnalyticsModel(clarityConfig: $clarityConfig, firebaseAnalyticsConfig: $firebaseAnalyticsConfig, faroConfig: $faroConfig, googleLoggingConfig: $googleLoggingConfig, splunkConfig: $splunkConfig)'; } +/// Default implementation of EngineAnalyticsModel with all services disabled. class EngineAnalyticsModelDefault implements EngineAnalyticsModel { @override EngineClarityConfig get clarityConfig => EngineClarityConfig(enabled: false, projectId: ''); diff --git a/lib/src/models/engine_bug_tracking_model.dart b/lib/src/models/engine_bug_tracking_model.dart index 2923e7f..0dd97eb 100644 --- a/lib/src/models/engine_bug_tracking_model.dart +++ b/lib/src/models/engine_bug_tracking_model.dart @@ -2,11 +2,24 @@ import 'package:engine_tracking/src/config/engine_crashlytics_config.dart'; import 'package:engine_tracking/src/config/engine_faro_config.dart'; import 'package:engine_tracking/src/config/engine_google_logging_config.dart'; +/// Model for bug tracking configuration in Engine Tracking. +/// +/// Aggregates all bug tracking service configurations. class EngineBugTrackingModel { + /// Creates a new bug tracking model. + /// + /// [crashlyticsConfig] - Firebase Crashlytics configuration. + /// [faroConfig] - Grafana Faro configuration. + /// [googleLoggingConfig] - Google Cloud Logging configuration. EngineBugTrackingModel({this.crashlyticsConfig, this.faroConfig, this.googleLoggingConfig}); + /// Firebase Crashlytics configuration. final EngineCrashlyticsConfig? crashlyticsConfig; + + /// Grafana Faro configuration. final EngineFaroConfig? faroConfig; + + /// Google Cloud Logging configuration. final EngineGoogleLoggingConfig? googleLoggingConfig; @override @@ -14,6 +27,7 @@ class EngineBugTrackingModel { 'EngineBugTrackingModel(crashlyticsConfig: $crashlyticsConfig, faroConfig: $faroConfig, googleLoggingConfig: $googleLoggingConfig)'; } +/// Default implementation of EngineBugTrackingModel with all services disabled. class EngineBugTrackingModelDefault implements EngineBugTrackingModel { @override EngineCrashlyticsConfig get crashlyticsConfig => EngineCrashlyticsConfig(enabled: false); diff --git a/lib/src/observers/engine_navigator_observer.dart b/lib/src/observers/engine_navigator_observer.dart index 915112e..b00a13e 100644 --- a/lib/src/observers/engine_navigator_observer.dart +++ b/lib/src/observers/engine_navigator_observer.dart @@ -1,7 +1,13 @@ import 'package:engine_tracking/src/src.dart'; import 'package:flutter/widgets.dart'; +/// Navigator observer that automatically tracks page navigation for analytics +/// +/// This class extends RouteObserver to automatically track page navigation +/// events and send them to the analytics system when routes are pushed, +/// popped, or replaced. class EngineNavigationObserver extends RouteObserver> { + /// Default route name used when no route name is available final String rootRouteName = 'root'; @override Future didPop(final Route route, final Route? previousRoute) async { diff --git a/lib/src/session/engine_session.dart b/lib/src/session/engine_session.dart index e298ef4..1481fb7 100644 --- a/lib/src/session/engine_session.dart +++ b/lib/src/session/engine_session.dart @@ -1,13 +1,22 @@ import 'dart:math'; +/// Session management for Engine Tracking +/// +/// This class provides session management functionality including +/// session ID generation and enrichment of data with session information. class EngineSession { EngineSession._(); + /// Singleton instance of EngineSession static EngineSession? _i; + + /// Returns the singleton instance of EngineSession static EngineSession get instance => _i ??= EngineSession._(); + /// Current session ID String? _sessionId; + /// Returns the current session ID, generating a new one if needed String get sessionId => _sessionId ??= _generateUUID(); String _generateHex(final int length) { @@ -32,12 +41,20 @@ class EngineSession { return '$part1-$part2-$part3-$part4-$part5'; } + /// Enriches data with the current session ID + /// + /// This method adds the current session ID to the provided data map, + /// creating a new map if the input is null. + /// + /// [data] The data map to enrich with session ID + /// Returns a new map containing the original data plus session ID Map? enrichWithSessionId(final Map? data) { final enriched = {...?data}; enriched['session_id'] = sessionId; return enriched; } + /// Resets the singleton instance for testing purposes static void resetForTesting() { _i = null; } diff --git a/lib/src/utils/engine_util.dart b/lib/src/utils/engine_util.dart index c6a82c8..52afeb8 100644 --- a/lib/src/utils/engine_util.dart +++ b/lib/src/utils/engine_util.dart @@ -1,8 +1,18 @@ import 'package:engine_tracking/engine_tracking.dart'; +/// Function type for filtering analytics adapters typedef PredicateAnalytics = bool Function(IEngineAnalyticsAdapter); + +/// Function type for filtering bug tracking adapters typedef PredicateBugTracking = bool Function(IEngineBugTrackingAdapter); +/// Converts a `Map` to `Map` +/// +/// This utility function converts all values in the input map to strings +/// using their toString() method. +/// +/// [map] The input map to convert +/// Returns a new map with string values, or null if input is null Map? convertToStringMap(final Map? map) { if (map == null) { return null; diff --git a/lib/src/widgets/engine_mask_widget.dart b/lib/src/widgets/engine_mask_widget.dart index d6feaa8..874e673 100644 --- a/lib/src/widgets/engine_mask_widget.dart +++ b/lib/src/widgets/engine_mask_widget.dart @@ -13,11 +13,15 @@ import 'package:flutter/material.dart'; /// ) /// ``` class EngineMaskWidget extends StatelessWidget { + /// Creates a new EngineMaskWidget + /// + /// [child] The widget to mask const EngineMaskWidget({ required this.child, super.key, }); + /// The widget to mask from recordings final Widget child; @override @@ -45,11 +49,15 @@ class EngineMaskWidget extends StatelessWidget { /// ) /// ``` class EngineUnmaskWidget extends StatelessWidget { + /// Creates a new EngineUnmaskWidget + /// + /// [child] The widget to unmask const EngineUnmaskWidget({ required this.child, super.key, }); + /// The widget to unmask in recordings final Widget child; @override diff --git a/lib/src/widgets/engine_stateful_widget.dart b/lib/src/widgets/engine_stateful_widget.dart index 22285f1..828a69b 100644 --- a/lib/src/widgets/engine_stateful_widget.dart +++ b/lib/src/widgets/engine_stateful_widget.dart @@ -3,26 +3,45 @@ import 'dart:async'; import 'package:engine_tracking/engine_tracking.dart'; import 'package:flutter/widgets.dart'; +/// Base class for stateful widgets with automatic tracking capabilities +/// +/// This abstract class provides automatic screen tracking, lifecycle events, +/// and user action logging for stateful widgets. abstract class EngineStatefulWidget extends StatefulWidget { + /// Creates a new EngineStatefulWidget + /// + /// [key] The widget key const EngineStatefulWidget({super.key}); @override EngineStatefulWidgetState createState(); } +/// State class for EngineStatefulWidget with tracking capabilities +/// +/// This abstract class provides automatic tracking functionality including +/// screen lifecycle events, user actions, and custom events. abstract class EngineStatefulWidgetState extends State { + /// Creates a new EngineStatefulWidgetState + /// + /// Initializes the screen open time for tracking purposes. EngineStatefulWidgetState() { _screenOpenTime = DateTime.now(); } + /// Returns the screen name for tracking purposes String get screenName => runtimeType.toString(); + /// Returns screen parameters for tracking Map? get screenParameters => null; + /// Whether to enable automatic screen tracking bool get enableAutoTracking => true; + /// Whether to enable lifecycle event tracking bool get enableLifecycleTracking => true; + /// Timestamp when the screen was opened late final DateTime _screenOpenTime; @override @@ -70,6 +89,7 @@ abstract class EngineStatefulWidgetState extends @override Widget build(final BuildContext context) => buildWithTracking(context); + /// Build method that includes tracking functionality Widget buildWithTracking(final BuildContext context); Future _trackScreenView() async { @@ -83,6 +103,10 @@ abstract class EngineStatefulWidgetState extends ); } + /// Logs a user action with screen context + /// + /// [action] The action being performed + /// [parameters] Optional parameters for the action Future logUserAction( final String action, { final Map? parameters, @@ -100,6 +124,10 @@ abstract class EngineStatefulWidgetState extends ); } + /// Logs a custom event with screen context + /// + /// [eventName] The name of the custom event + /// [parameters] Optional parameters for the event Future logCustomEvent( final String eventName, { final Map? parameters, @@ -117,6 +145,12 @@ abstract class EngineStatefulWidgetState extends ); } + /// Logs a screen error with context + /// + /// [reason] The reason for the error + /// [exception] Optional exception object + /// [stackTrace] Optional stack trace + /// [additionalData] Optional additional error data Future logScreenError( final String reason, { final Object? exception, @@ -137,6 +171,10 @@ abstract class EngineStatefulWidgetState extends ); } + /// Logs a state change with screen context + /// + /// [stateDescription] Description of the state change + /// [additionalData] Optional additional data about the state change Future logStateChange( final String stateDescription, { final Map? additionalData, diff --git a/lib/src/widgets/engine_stateless_widget.dart b/lib/src/widgets/engine_stateless_widget.dart index 6cd8162..d5707f8 100644 --- a/lib/src/widgets/engine_stateless_widget.dart +++ b/lib/src/widgets/engine_stateless_widget.dart @@ -24,6 +24,9 @@ import 'package:flutter/widgets.dart'; /// } /// ``` abstract class EngineStatelessWidget extends StatelessWidget { + /// Creates a new EngineStatelessWidget + /// + /// [key] The widget key EngineStatelessWidget({super.key}) { _screenOpenTime = DateTime.now(); diff --git a/lib/src/widgets/engine_widget.dart b/lib/src/widgets/engine_widget.dart index ed74c8c..81592f4 100644 --- a/lib/src/widgets/engine_widget.dart +++ b/lib/src/widgets/engine_widget.dart @@ -35,6 +35,10 @@ import 'package:flutter/material.dart'; /// } /// ``` class EngineWidget extends StatelessWidget { + /// Creates a new EngineWidget + /// + /// [app] The main application widget to wrap + /// [key] The widget key const EngineWidget({ required this.app, super.key, From 1a85486a0c406e8478a99b672fa92077f12209fe Mon Sep 17 00:00:00 2001 From: Thiago Moreira Date: Thu, 24 Jul 2025 00:12:03 -0300 Subject: [PATCH 2/2] fix: resolve deprecated userId warning in Clarity adapter --- lib/src/analytics/adapters/engine_clarity_adapter.dart | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/lib/src/analytics/adapters/engine_clarity_adapter.dart b/lib/src/analytics/adapters/engine_clarity_adapter.dart index 802707c..52f3fa5 100644 --- a/lib/src/analytics/adapters/engine_clarity_adapter.dart +++ b/lib/src/analytics/adapters/engine_clarity_adapter.dart @@ -79,7 +79,8 @@ class EngineClarityAdapter implements IEngineAnalyticsAdapter setUserId(final String? userId, [final String? email, final String? name]) async { - Clarity.setCustomUserId(userId ?? email ?? name ?? ''); + final customUserId = userId ?? email ?? name ?? ''; + Clarity.setCustomUserId(customUserId); await Future.value(null); }