feat(#32): block works on tracer for now

packages/serinus/lib/src/core/application.dart

@@ -190,8 +190,9 @@ class SerinusApplication extends Application {
     _logger.info('Hook ${hook.runtimeType} added to application');
   }
 
+  /// The [trace] method is used to add a tracer to the application.
   void trace(Tracer tracer) {
-    config.tracers.add(tracer);
+    config.addTracer(tracer);
     _logger.info('Tracer ${tracer.name}(${tracer.runtimeType}) added to application');
   }
 }

packages/serinus/lib/src/core/application_config.dart

@@ -104,13 +104,21 @@ final class ApplicationConfig {
   final Set<Hook> hooks = {};
 
   /// The tracer for the application
-  final Set<Tracer> tracers = {};
+  Tracer? _tracer;
+
+  /// The tracer for the application
+  Tracer? get tracer => _tracer;
 
   /// Add a hook to the application
   void addHook(Hook hook) {
     hooks.add(hook);
   }
 
+  /// Add a tracer to the application
+  void addTracer(Tracer tracer) {
+    _tracer = tracer;
+  }
+
   /// The application config constructor
   ApplicationConfig({
     required this.host,

packages/serinus/lib/src/handlers/request_handler.dart

@@ -34,55 +34,27 @@ class RequestHandler extends Handler {
   @override
   Future<void> handleRequest(
       InternalRequest request, InternalResponse response) async {
-    for(final tracer in config.tracers){
-      tracer.startTracing();
-    }
+    config.tracer?.startTracing();
     final Request wrappedRequest = Request(request);
     await onRequest(wrappedRequest, response);
     await wrappedRequest.parseBody();
-    Response result;
     final specifications = getRoute(wrappedRequest);
     final context = specifications.context;
     final route = specifications.route;
     final handler = specifications.handler;
     final middlewares = specifications.middlewares;
     await onTransformAndParse(context, route);
     if (middlewares.isNotEmpty) {
-      await handleMiddlewares(
-        context,
-        response,
-        middlewares,
-      );
-      for(final tracer in config.tracers){
-        tracer.onMiddlewares(context);
-      }
-    }
-    for (final hook in config.hooks) {
+      await onMiddlewares(context, response, middlewares);
       if (response.isClosed) {
         return;
       }
-      await hook.beforeHandle(context);
-    }
-    await route.beforeHandle(context);
-    for(final tracer in config.tracers){
-      tracer.onBeforeHandle(context);
-    }
-    result = await handler.call(context);
-    for(final tracer in config.tracers){
-      tracer.onHandle(context);
-    }
-    await route.afterHandle(context, result);
-    for (final hook in config.hooks) {
-      if (response.isClosed) {
-        return;
-      }
-      await hook.afterHandle(context, result);
-    }
-    for(final tracer in config.tracers){
-      tracer.onAfterHandle(context);
     }
+    await onBeforeHandle(context, route);
+    final Response result = await onHandle(context, route, handler);
+    await onAfterHandle(context, route, result);
     await response.finalize(result,
-        viewEngine: config.viewEngine, hooks: config.hooks, tracers: config.tracers);
+        viewEngine: config.viewEngine, hooks: config.hooks, tracer: config.tracer);
   }
 
   /// Handles the middlewares
@@ -112,21 +84,42 @@ class RequestHandler extends Handler {
       }
       await hook.onRequest(request, response);
     }
-    for (final tracer in config.tracers){
-      tracer.onRequest(request);
-    }
+    await config.tracer?.onRequest(request);
   }
 
   /// Transforms and parses the request
   Future<void> onTransformAndParse(RequestContext context, Route route) async {
     await route.transform(context);
-    for (final tracer in config.tracers){
-      tracer.onTranform(context);
-    }
+    await config.tracer?.onTranform(context);
     await route.parse(context);
-    for (final tracer in config.tracers){
-      tracer.onParse(context);
+    await config.tracer?.onParse(context);
+  }
+
+  Future<void> onMiddlewares(RequestContext context, InternalResponse response, Iterable<Middleware> middlewares) async {
+    await handleMiddlewares(context, response, middlewares);
+    await config.tracer?.onMiddlewares(context);
+  }
+
+  Future<void> onBeforeHandle(RequestContext context, Route route) async {
+    for (final hook in config.hooks) {
+      await hook.beforeHandle(context);
+    }
+    await route.beforeHandle(context);
+    await config.tracer?.onBeforeHandle(context);
+  }
+
+  Future<Response> onHandle(RequestContext context, Route route, ReqResHandler handler) async {
+    final result = await handler.call(context);
+    await config.tracer?.onHandle(context);
+    return result;
+  }
+
+  Future<void> onAfterHandle(RequestContext context, Route route, Response response) async {
+    await route.afterHandle(context, response);
+    for (final hook in config.hooks) {
+      await hook.afterHandle(context, response);
     }
+    await config.tracer?.onAfterHandle(context);
   }
 
   /// Gets the route data from the [Router] and the controller from the [ModulesContainer]

packages/serinus/lib/src/http/internal_response.dart

@@ -106,7 +106,7 @@ class InternalResponse {
   Future<void> finalize(Response result,
       {ViewEngine? viewEngine,
       VersioningOptions? versioning,
-      Set<Hook> hooks = const {}, Set<Tracer> tracers = const {}}) async {
+      Set<Hook> hooks = const {}, Tracer? tracer}) async {
     _events.add(ResponseEvent.beforeSend);
     status(result.statusCode);
     if (result.shouldRedirect) {
@@ -127,9 +127,7 @@ class InternalResponse {
       for (final hook in hooks) {
         await hook.onResponse(result);
       }
-      for(final tracer in tracers){
-        tracer.onResponse(result);
-      }
+      await tracer?.onResponse(result);
       headers(result.headers);
       return send(utf8.encode(rendered));
     }
@@ -148,9 +146,7 @@ class InternalResponse {
       for (final hook in hooks) {
         await hook.onResponse(result);
       }
-      for(final tracer in tracers){
-        tracer.onResponse(result);
-      }
+      await tracer?.onResponse(result);
       headers(result.headers);
       final readPipe = data.openRead();
       await sendStream(readPipe);
@@ -176,9 +172,7 @@ class InternalResponse {
     for (final hook in hooks) {
       await hook.onResponse(result);
     }
-    for(final tracer in tracers){
-      tracer.onResponse(result);
-    }
+    await tracer?.onResponse(result);
     headers(result.headers);
     return send(utf8.encode(data.toString()));
   }