diff --git a/mapchete/processing/profilers/memory.py b/mapchete/processing/profilers/memory.py
index 76a2f1bf..29b2329d 100644
--- a/mapchete/processing/profilers/memory.py
+++ b/mapchete/processing/profilers/memory.py
@@ -1,13 +1,13 @@
 import logging
 import os
 import uuid
-from contextlib import ExitStack
 from dataclasses import dataclass
 from tempfile import TemporaryDirectory
 from typing import Any, Callable, Optional, Tuple, Union
 
 from mapchete.io import copy
 from mapchete.path import MPath
+from mapchete.pretty import pretty_bytes
 from mapchete.types import MPathLike
 
 logger = logging.getLogger(__name__)
@@ -47,9 +47,9 @@ def wrapped_f(*args, **kwargs) -> Union[Any, Tuple[Any, MeasuredMemory]]:
                 return (retval, result)
 
             logger.info(
-                "function %s consumed a maximum of %sMB",
+                "function %s consumed a maximum of %s",
                 func,
-                round(tracker.max_allocated / 1024 / 1024, 2),
+                pretty_bytes(tracker.max_allocated),
             )
             return retval
 
@@ -75,47 +75,43 @@ def __init__(
             import memray
         except ImportError:  # pragma: no cover
             raise ImportError("please install memray if you want to use this feature.")
+
         self.output_file = MPath.from_inp(output_file) if output_file else None
-        self._exit_stack = ExitStack()
-        self._temp_dir = self._exit_stack.enter_context(TemporaryDirectory())
+        self.raise_exc_multiple_trackers = raise_exc_multiple_trackers
+        self._temp_dir = TemporaryDirectory()
         self._temp_file = str(
-            MPath(self._temp_dir) / f"{os. getpid()}-{uuid.uuid4().hex}.bin"
+            MPath(self._temp_dir.name) / f"{os.getpid()}-{uuid.uuid4().hex}.bin"
         )
-        try:
-            self._memray_tracker = self._exit_stack.enter_context(
-                memray.Tracker(self._temp_file, follow_fork=True)
-            )
-        except RuntimeError as exc:  # pragma: no cover
-            if raise_exc_multiple_trackers:
-                raise
-            self._memray_tracker = None
-            logger.exception(exc)
+        self.memray_tracker = memray.Tracker(self._temp_file, follow_fork=True)
 
     def __str__(self):  # pragma: no cover
-        max_allocated = f"{self.max_allocated / 1024 / 1024:.2f}MB"
-        total_allocated = f"{self.total_allocated / 1024 / 1024:.2f}MB"
-        return f"<MemoryTracker max_allocated={max_allocated}, total_allocated={total_allocated}, allocations={self.allocations}>"
+        return f"<MemoryTracker max_allocated={pretty_bytes(self.max_allocated)}, total_allocated={pretty_bytes(self.total_allocated)}, allocations={self.allocations}>"
 
     def __repr__(self):  # pragma: no cover
         return repr(str(self))
 
     def __enter__(self):
+        self._temp_dir.__enter__()
+        try:
+            if self.memray_tracker:
+                self.memray_tracker.__enter__()
+        except RuntimeError as exc:  # pragma: no cover
+            if self.raise_exc_multiple_trackers:
+                raise
+            logger.exception(exc)
         return self
 
     def __exit__(self, *args):
         try:
-            try:
-                from memray import FileReader
-            except ImportError:  # pragma: no cover
-                raise ImportError(
-                    "please install memray if you want to use this feature."
-                )
+            from memray import FileReader
+
             # close memray.Tracker before attempting to read file
-            if self._memray_tracker:
-                self._memray_tracker.__exit__(*args)
-            reader = FileReader(self._temp_file)
+            if self.memray_tracker:
+                self.memray_tracker.__exit__(*args)
             allocations = list(
-                reader.get_high_watermark_allocation_records(merge_threads=True)
+                FileReader(self._temp_file).get_high_watermark_allocation_records(
+                    merge_threads=True
+                )
             )
             self.max_allocated = max(record.size for record in allocations)
             self.total_allocated = sum(record.size for record in allocations)
@@ -123,6 +119,6 @@ def __exit__(self, *args):
             if self.output_file:
                 copy(self._temp_file, self.output_file, overwrite=True)
         finally:
-            self._exit_stack.__exit__(*args)
+            self._temp_dir.__exit__(*args)
             # we need to set this to None, so MemoryTracker can be serialized
-            self._memray_tracker = None
+            self.memray_tracker = None
diff --git a/mapchete/processing/tasks.py b/mapchete/processing/tasks.py
index ad515a77..9a875535 100644
--- a/mapchete/processing/tasks.py
+++ b/mapchete/processing/tasks.py
@@ -120,7 +120,7 @@ def __geo_interface__(self) -> mapping:
             raise NoTaskGeometry(f"{self} has no geo information assigned")
 
 
-def _execute_task_wrapper(task, **kwargs) -> Any:
+def _execute_task_wrapper(task, **kwargs) -> Any:  # pragma: no cover
     return task.execute(**kwargs)
 
 
@@ -201,7 +201,7 @@ class InterpolateFrom(str, Enum):
     higher = "higher"
 
 
-def _execute_tile_task_wrapper(task, **kwargs) -> Any:
+def _execute_tile_task_wrapper(task, **kwargs) -> Any:  # pragma: no cover
     return task.execute(**kwargs)
 
 
diff --git a/test/test_processing_tasks.py b/test/test_processing_tasks.py
index 9520f373..7a6de434 100644
--- a/test/test_processing_tasks.py
+++ b/test/test_processing_tasks.py
@@ -123,9 +123,10 @@ def test_task_batches_to_dask_graph(dem_to_hillshade):
         for zoom in dem_to_hillshade.mp().config.zoom_levels.descending()
     )
     collection = Tasks((preprocessing_batch, *zoom_batches)).to_dask_graph()
-    import dask
-
-    dask.compute(collection)
+    assert collection
+    # deactivated this because it stalls GitHub action
+    # import dask
+    # dask.compute(collection, scheduler=dask_executor._executor_client)
 
 
 def test_task_batches_mixed_geometries():
@@ -196,9 +197,9 @@ def test_task_batches_as_dask_graph(dem_to_hillshade):
     graph = task_batches.to_dask_graph()
     assert graph
 
-    import dask
-
-    dask.compute(graph)
+    # deactivated this because it stalls GitHub action
+    # import dask
+    # dask.compute(graph, scheduler=dask_executor._executor_client)
 
 
 def test_task_batches_as_layered_batches(dem_to_hillshade):