How to **identify mutation methods** in a notifier?

[mrverdant13]

Hey, there! 👋🏼

I've got a question that may be related to analytics
Is there any way to identify which of the mutation methods of an AsyncNotifier got triggered?
I'd like to send the intent event to the analytics service

Here is an example:
Given a ProductNotifier that exposes the updateName, updateDescription, and updatePrice methods, how could I discriminate which of those methods got invoked within a ProviderObserver?

The only way I managed to achieve this was by creating independent notifiers, one per mutation method and with AsyncValue<void> states, which can be directly recognized in the ProviderObserver methods.

Besides that, the mentioned alternative does not provide access to the potential payload of the mutation methods, i.e. in case I'd like to post to price change intent.

I often use this pattern with the bloc package by accessing the events, which also include the event metadata or payload, in the observer.

There is no such thing in Riverpod, and I believe it is a valuable feature that could be considered in case it is not already included.

[rrousselGit]

There's not much you can do currently.

Mutations will enable tracking that sort of thing. But if you want to handle that today, you'll have to build something yourself.

[mrverdant13]

Thanks for the quick reply, Remi
That's what I thought 🫤

I've been doing some naive tests recently trying to address this limitation.
I am posting these tests here in case they may help someone else as reference.

[mrverdant13]

I've been doing some naive tests recently trying to address this limitation.
I am posting these tests here in case they may help someone else as reference.

Some notes:

• Only the examples 02 and 03 are the ones that fitted my needs, but more tests are required to be fully aware of other potetial issues they may bring.
• The overriden toString methods could be considered as the analytics mapping behaviour that can be checked by the ProviderObserver to filter out reportable mutations as analytics events, that is why the need of custom async states: to hold event metadata (in this case, parameters such as the summand and the factor).

Example 01 - Reference standard implementation (does not allow traceability)

@riverpod
class NumberExample01 extends _$NumberExample01 {
  @override
  Future<double> build() async {
    await Future<void>.delayed(const Duration(seconds: 1));
    return 1;
  }

  Future<void> add(double value) async {
    if (state is AsyncLoading) return;
    state = const AsyncLoading<double>().copyWithPrevious(state);
    await Future<void>.delayed(const Duration(seconds: 1));
    final currentValue = await future;
    state = await AsyncValue.guard(
      () async => currentValue + value,
    );
  }

  Future<void> multiply(double value) async {
    if (state is AsyncLoading) return;
    state = const AsyncLoading<double>().copyWithPrevious(state);
    await Future<void>.delayed(const Duration(seconds: 1));
    final currentValue = await future;
    state = await AsyncValue.guard(
      () async => currentValue * value,
    );
  }
}

Example 02 - One notifier per mutation (fine-grained traceability)

@riverpod
class NumberExample02 extends _$NumberExample02 {
  @override
  Future<double> build() async {
    await Future<void>.delayed(const Duration(seconds: 1));
    return 1;
  }

  @visibleForTesting
  Future<void> set(double value) async {
    state = AsyncData(value);
  }
}

@riverpod
class NumberExampleAdder02 extends _$NumberExampleAdder02 {
  @override
  AdderState build() {
    return const AdderIdle();
  }

  Future<void> call(double summand) async {
    if (state is AdderLoading) return;
    state = AdderLoading(summand);
    final currentValue = await ref.read(numberExample02Pod.future);
    try {
      await Future<void>.delayed(const Duration(seconds: 1));
      await ref.read(numberExample02Pod.notifier).set(currentValue + summand);
      state = const AdderIdle();
    } catch (error, stackTrace) {
      state = AdderFailed(
        error,
        stackTrace,
      );
    }
  }
}

sealed class AdderState {
  const AdderState();
}

class AdderIdle extends AdderState {
  const AdderIdle();

  @override
  String toString() {
    return 'AdderIdle()';
  }
}

class AdderLoading extends AdderState {
  const AdderLoading(this.summand);

  final double summand;

  @override
  String toString() {
    return 'AdderLoading(summand: $summand)';
  }
}

class AdderFailed extends AdderState {
  const AdderFailed(
    this.error,
    this.stackTrace,
  );

  final Object error;
  final StackTrace stackTrace;

  @override
  String toString() {
    return 'AdderFailed(error: $error, stackTrace: $stackTrace)';
  }
}

@riverpod
class NumberExampleMultiplier02 extends _$NumberExampleMultiplier02 {
  @override
  MultiplierState build() {
    return const MultiplierIdle();
  }

  Future<void> call(double factor) async {
    if (state is MultiplierLoading) return;
    state = MultiplierLoading(factor);
    final currentValue = await ref.read(numberExample02Pod.future);
    try {
      await Future<void>.delayed(const Duration(seconds: 1));
      await ref.read(numberExample02Pod.notifier).set(currentValue * factor);
      state = const MultiplierIdle();
    } catch (error, stackTrace) {
      state = MultiplierFailed(
        error,
        stackTrace,
      );
    }
  }
}

sealed class MultiplierState {
  const MultiplierState();
}

class MultiplierIdle extends MultiplierState {
  const MultiplierIdle();

  @override
  String toString() {
    return 'MultiplierIdle()';
  }
}

class MultiplierLoading extends MultiplierState {
  const MultiplierLoading(this.factor);

  final double factor;

  @override
  String toString() {
    return 'MultiplierLoading(factor: $factor)';
  }
}

class MultiplierFailed extends MultiplierState {
  const MultiplierFailed(
    this.error,
    this.stackTrace,
  );

  final Object error;
  final StackTrace stackTrace;

  @override
  String toString() {
    return 'MultiplierFailed(error: $error, stackTrace: $stackTrace)';
  }
}

Example 03 - Single mutator notifier with inner sub-mutation states (grouped traceability)

@riverpod
class NumberExample03 extends _$NumberExample03 {
  @override
  Future<double> build() async {
    await Future<void>.delayed(const Duration(seconds: 1));
    return 1;
  }

  @visibleForTesting
  Future<void> set(double value) async {
    state = AsyncData(value);
  }
}

@riverpod
class NumberExampleMutator03 extends _$NumberExampleMutator03 {
  @override
  MutatorState build() {
    return const MutatorState(
      addState: AddIdle(),
      multiplyState: MultiplyIdle(),
    );
  }

  Future<void> add(double summand) async {
    if (state.isLoading) return;
    state = state.copyWith(
      addState: AddLoading(summand),
    );
    final currentValue = await ref.read(numberExample03Pod.future);
    try {
      await Future<void>.delayed(const Duration(seconds: 1));
      await ref.read(numberExample03Pod.notifier).set(currentValue + summand);
      state = state.copyWith(
        addState: const AddIdle(),
      );
    } catch (error, stackTrace) {
      state = state.copyWith(
        addState: AddFailed(
          error,
          stackTrace,
        ),
      );
    }
  }

  Future<void> multiply(double factor) async {
    if (state.isLoading) return;
    state = state.copyWith(
      multiplyState: MultiplyLoading(factor),
    );
    final currentValue = await ref.read(numberExample03Pod.future);
    try {
      await Future<void>.delayed(const Duration(seconds: 1));
      await ref.read(numberExample03Pod.notifier).set(currentValue * factor);
      state = state.copyWith(
        multiplyState: const MultiplyIdle(),
      );
    } catch (error, stackTrace) {
      state = state.copyWith(
        multiplyState: MultiplyFailed(
          error,
          stackTrace,
        ),
      );
    }
  }
}

final class MutatorState {
  const MutatorState({
    required this.addState,
    required this.multiplyState,
  });

  MutatorState copyWith({
    AddState? addState,
    MultiplyState? multiplyState,
  }) {
    return MutatorState(
      addState: addState ?? this.addState,
      multiplyState: multiplyState ?? this.multiplyState,
    );
  }

  final AddState addState;
  final MultiplyState multiplyState;

  bool get isLoading {
    return addState is AddLoading || multiplyState is MultiplyLoading;
  }

  @override
  String toString() {
    return '''
MutatorState(
  addState: $addState
  multiplyState: $multiplyState
)''';
  }
}

sealed class AddState {
  const AddState();
}

class AddIdle extends AddState {
  const AddIdle();

  @override
  String toString() {
    return 'AddIdle()';
  }
}

class AddLoading extends AddState {
  const AddLoading(this.summand);

  final double summand;

  @override
  String toString() {
    return 'AddLoading(summand: $summand)';
  }
}

class AddFailed extends AddState {
  const AddFailed(
    this.error,
    this.stackTrace,
  );

  final Object error;
  final StackTrace stackTrace;

  @override
  String toString() {
    return 'AddFailed(error: $error, stackTrace: $stackTrace)';
  }
}

sealed class MultiplyState {
  const MultiplyState();
}

class MultiplyIdle extends MultiplyState {
  const MultiplyIdle();

  @override
  String toString() {
    return 'MultiplyIdle()';
  }
}

class MultiplyLoading extends MultiplyState {
  const MultiplyLoading(this.factor);

  final double factor;

  @override
  String toString() {
    return 'MultiplyLoading(factor: $factor)';
  }
}

class MultiplyFailed extends MultiplyState {
  const MultiplyFailed(
    this.error,
    this.stackTrace,
  );

  final Object error;
  final StackTrace stackTrace;

  @override
  String toString() {
    return 'MultiplyFailed(error: $error, stackTrace: $stackTrace)';
  }
}

Consumer widgets

class MyWidget extends ConsumerWidget {
  const MyWidget({
    super.key,
  });

  @override
  Widget build(BuildContext context, WidgetRef ref) {
    return Column(
      mainAxisSize: MainAxisSize.min,
      children: [
        const Divider(
          color: Colors.transparent,
        ),
        const Text(
          'Example 01',
          textAlign: TextAlign.center,
          style: TextStyle(fontWeight: FontWeight.bold),
        ),
        Text(
          ref.watch(numberExample01Pod).when(
                data: (value) => '$value',
                error: (_, __) => 'Error',
                loading: () => 'Loading...',
              ),
          textAlign: TextAlign.center,
        ),
        Row(
          mainAxisSize: MainAxisSize.min,
          children: [
            IconButton(
              icon: const Icon(Icons.add),
              onPressed: () {
                ref.read(numberExample01Pod.notifier).add(1);
              },
            ),
            IconButton(
              icon: const Icon(Icons.close),
              onPressed: () {
                ref.read(numberExample01Pod.notifier).multiply(-1);
              },
            ),
          ],
        ),
        const Divider(),
        const Text(
          'Example 02',
          textAlign: TextAlign.center,
          style: TextStyle(fontWeight: FontWeight.bold),
        ),
        Text(
          ref.watch(numberExample02Pod).when(
                data: (value) => '$value',
                error: (_, __) => 'Error',
                loading: () => 'Loading...',
              ),
          textAlign: TextAlign.center,
        ),
        Row(
          mainAxisSize: MainAxisSize.min,
          children: [
            IconButton(
              icon: const Icon(Icons.add),
              onPressed: () {
                ref.read(numberExampleAdder02Pod.notifier).call(1);
              },
            ),
            IconButton(
              icon: const Icon(Icons.close),
              onPressed: () {
                ref.read(numberExampleMultiplier02Pod.notifier).call(-1);
              },
            ),
          ],
        ),
        const Divider(),
        const Text(
          'Example 03',
          textAlign: TextAlign.center,
          style: TextStyle(fontWeight: FontWeight.bold),
        ),
        Text(
          ref.watch(numberExample03Pod).when(
                data: (value) => '$value',
                error: (_, __) => 'Error',
                loading: () => 'Loading...',
              ),
          textAlign: TextAlign.center,
        ),
        Row(
          mainAxisSize: MainAxisSize.min,
          children: [
            IconButton(
              icon: const Icon(Icons.add),
              onPressed: () {
                ref.read(numberExampleMutator03Pod.notifier).add(1);
              },
            ),
            IconButton(
              icon: const Icon(Icons.close),
              onPressed: () {
                ref.read(numberExampleMutator03Pod.notifier).multiply(-1);
              },
            ),
          ],
        ),
        const Divider(
          color: Colors.transparent,
        ),
      ],
    );
  }
}

[rrousselGit]

You'd likely be better off with a mixin that adds a custom state =, and rely on the stacktrace

typedef WithTrace<T> = ({T value, StackTrace stackTrace});

mixin WithTraceMixin<T> {
  abstract T state;

  setState(T value) => state =  (value: value, stackTrace: StackTrace.current);
}

Then:

@riverpod
class Example extrends Notifier<int> with WithTraceMixin<int> {
  build( ) => 0;

  void increment() => setState(state + 1);
}

// Inside an observer:
if (value is WithTrace) {
  log(value.value, value.stackTrace);
}

[rrousselGit]

Thinking about it, simply logging StackTrace.current inside the observer might be enough.

I would assume that all life-cycles will contain the invoking method in it.

[mrverdant13]

I also considered that workaround
The trace references the triggering mutation method, indeed, which is somehow useful to some extent.
Unfortunately, the invocation metadata, particularly the method args are not actually accessible.

#1      LoggingPodsObserver.didUpdateProvider (package:altoke_app/app/state/logging_provider_observer.dart:185:35)
#2      runQuaternaryGuarded (package:riverpod/src/run_guarded.dart:60:7)
#3      ProviderElementBase._notifyListeners (package:riverpod/src/framework/element.dart:575:7)
#4      ProviderElementBase.setState (package:riverpod/src/framework/element.dart:158:7)
#5      AsyncTransition.asyncTransition (package:riverpod/src/common.dart:28:7)
#6      FutureHandlerProviderElementMixin.onData (package:riverpod/src/async_notifier/base.dart:277:7)
#7      AsyncData.map (package:riverpod/src/common.dart:324:16)
#8      FutureHandlerProviderElementMixin.state= (package:riverpod/src/async_notifier/base.dart:205:14)
#9      AsyncNotifierBase.state= (package:riverpod/src/async_notifier.dart:57:14)
#10     NumberExample01.multiply (package:altoke_app/tasks/state/async_tasks.pod.dart:114:5)

Here, I can verify that NumberExample01.multiply was the triggering mutation method, but I cannot check the value of the provided factor parameter.
This method would be also affected by obfuscation, when applied.

Using the stack_trace package may simplify some things, but the functionality would still be limited.