feat: Add hooks for easy performance tracing

[ueman]

Description

I'm currently experimenting with automatic performance tracing for blocs. For that I would like to hook somehow into blocs easily.

I'm especially interested in tracing the time an EventHandler takes to execute. That method basically represents the code which is executed after adding an event until that work is handled. At least that's my understanding.

By performance tracing I mean to trace it with tools like Sentry, Datadog, etc. I don't mean the Dart Dev Tools.

Desired Solution

I think I need some hooks around this code:

bloc/packages/bloc/lib/src/bloc.dart

Lines 224 to 232 in e51483d

	try {
	_emitters.add(emitter);
	await handler(event as E, emitter);
	} catch (error, stackTrace) {
	onError(error, stackTrace);
	rethrow;
	} finally {
	onDone();
	}

try {
  _emitters.add(emitter);
  // I want to start tracing here
  await handler(event as E, emitter);
  // I want to end tracing here
} catch (error, stackTrace) {
  onError(error, stackTrace);
  rethrow;
} finally {
  onDone();
}

Ideally, I'm also able to wrap await handler(event as E, emitter); somehow myself in a try catch so that I can set the status of the trace to something like success/failure.

Something like the following pseudo code would be sufficient:

typedef Executor = FutureOr<void> Function(handler, event, emitter);
class Bloc {
  static Executor? executor;

  /// ...
  try {
    _emitters.add(emitter);
    if(executor != null) {
      await executor(handler, event, emitter);
    } else {
      await handler(event as E, emitter);
    }
  } catch (error, stackTrace) {
    onError(error, stackTrace);
    rethrow;
  } finally {
    onDone();
  }
  /// ...
}

Bloc.executor = (handler, event, emitter) {
  startTransaction();
  try {
    await handler(event as E, emitter);
    stopTransactionWithSuccess();
  } catch(_) {
    stopTransactionWithFailure();
    rethrow;
  }
}

Alternatives Considered

I'm not really well versed with bloc so I'm not aware of any other possible approach. I'm therefore open for any alternative approaches or suggestions.

Additional Context

[felangel]

Hi @ueman 👋
Thanks for opening an issue!

The following is invoking your custom event handlers registered in the bloc via on<E>(handler).

await handler(event as E, emitter);

You can create a profiling handler like:

import 'package:bloc/bloc.dart';

void main() {
  final bloc = CounterBloc()
    ..stream.listen(print)
    ..add(CounterEvent.increment);
}

enum CounterEvent {
  increment,
  decrement,
}

class CounterBloc extends Bloc<CounterEvent, int> {
  CounterBloc() : super(0) {
    on<CounterEvent>(
      profilingEventHandler((event, emit) {
        emit(state + 1);
      }),
    );
  }
}

EventHandler<E, S> profilingEventHandler<E, S>(EventHandler<E, S> handler) {
  return (event, emit) async {
    print('start transaction');
    try {
      await handler(event, emit);
      print('stop transaction');
    } catch (error) {
      print('stop transaction with error');
    }
  };
}

Let me know if that helps and sorry for the delayed response 👍

[ueman]

While this is definitely working, I was hoping for a more general solution for which I don't have to edit every single bloc class.