ci: update github-script action to v9

.github/scripts/setup_benchmark_env.sh

@@ -0,0 +1,52 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+bec_core_branch="${BEC_CORE_BRANCH:-main}"
+ophyd_devices_branch="${OPHYD_DEVICES_BRANCH:-main}"
+plugin_repo_branch="${PLUGIN_REPO_BRANCH:-main}"
+python_version="${PYTHON_VERSION:-3.11}"
+
+if command -v conda >/dev/null 2>&1; then
+  conda_base="$(conda info --base)"
+  source "$conda_base/etc/profile.d/conda.sh"
+fi
+
+echo "Using branch ${bec_core_branch} of BEC CORE"
+git clone --branch "$bec_core_branch" https://github.com/bec-project/bec.git
+
+echo "Using branch ${ophyd_devices_branch} of OPHYD_DEVICES"
+git clone --branch "$ophyd_devices_branch" https://github.com/bec-project/ophyd_devices.git
+
+echo "Using branch ${plugin_repo_branch} of bec_testing_plugin"
+git clone --branch "$plugin_repo_branch" https://github.com/bec-project/bec_testing_plugin.git
+
+conda create -q -n test-environment "python=${python_version}"
+conda activate test-environment
+
+cd bec
+source ./bin/install_bec_dev.sh
+cd ..
+
+python -m pip install -e ./ophyd_devices -e .[dev,pyside6] -e ./bec_testing_plugin
+
+benchmark_tmp_dir="$(mktemp -d)"
+export BEC_SERVICE_CONFIG="$benchmark_tmp_dir/services_config.yaml"
+
+# Start Redis
+redis-server --daemonize yes --port 6379
+
+# Wait for Redis to be ready
+timeout 30 bash -c 'until redis-cli ping > /dev/null 2>&1; do sleep 0.1; done' || {
+  echo "Redis failed to start" >&2
+  exit 1
+}
+
+# Start BEC server
+bec-server start --config "$BEC_SERVICE_CONFIG"
+
+# Wait for BEC server to be ready
+sleep 5
+
+# Export BEC client configuration
+export BEC_CONFIG='{"redis": {"host": "localhost", "port": 6379}}'
+

.github/scripts/start_bec_benchmark_services.py

@@ -0,0 +1,33 @@
+#!/usr/bin/env python3
+"""Start BEC services for benchmark workflows and keep them alive."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+from bec_ipython_client import BECIPythonClient
+from bec_lib.redis_connector import RedisConnector
+from bec_lib.service_config import ServiceConfig
+
+
+def _load_demo_config(services_config: Path) -> None:
+    bec = BECIPythonClient(ServiceConfig(services_config), RedisConnector, forced=True)
+    bec.start()
+    try:
+        bec.config.load_demo_config()
+    finally:
+        bec.shutdown()
+        bec._client._reset_singleton()
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--services-config", required=True, type=Path)
+    args = parser.parse_args()
+
+    _load_demo_config(args.services_config)
+
+
+if __name__ == "__main__":
+    main()

.github/workflows/benchmark.yml

@@ -0,0 +1,47 @@
+name: BW Benchmarks
+
+on: [ workflow_call ]
+
+permissions:
+  contents: read
+
+env:
+  QTWEBENGINE_DISABLE_SANDBOX: 1
+  QT_QPA_PLATFORM: "offscreen"
+
+jobs:
+  benchmark:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      issues: write
+      pull-requests: write
+    defaults:
+      run:
+        shell: bash -el {0}
+
+    steps:
+      - name: Checkout BEC Widgets
+        uses: actions/checkout@v4
+        with:
+          repository: bec-project/bec_widgets
+          ref: ${{ github.event.pull_request.head.sha || github.sha }}
+
+      - name: Set up Conda
+        uses: conda-incubator/setup-miniconda@v3
+        with:
+          auto-update-conda: true
+          auto-activate-base: true
+          python-version: "3.11"
+
+      - name: Run, compare, and publish benchmarks
+        uses: bec-project/benchmark_action@main
+        with:
+          mode: all
+          attempts: "3"
+          system-packages: libgl1 libegl1 x11-utils libxkbcommon-x11-0 libdbus-1-3 xvfb
+            libnss3 libxdamage1 libasound2t64 libatomic1 libxcursor1 hyperfine
+            redis-server
+          setup-scripts: .github/scripts/setup_benchmark_env.sh
+          benchmark-pytest-dirs: tests/unit_tests/benchmarks
+          threshold-percent: "10"

.github/workflows/check_pr.yml

@@ -12,7 +12,7 @@ jobs:
     outputs:
       branch-pr: ${{ steps.script.outputs.result }}
     steps:
-      - uses: actions/github-script@v7
+      - uses: actions/github-script@v9
         id: script
         if: github.event_name == 'push' && github.event.ref_type != 'tag'
         with:
@@ -25,4 +25,4 @@ jobs:
             if (prs.data.length) {
               console.log(`::notice ::Skipping CI on branch push as it is already run in PR #${prs.data[0]["number"]}`)
               return prs.data[0]["number"]
-            }
+            }

.github/workflows/ci.yml

@@ -1,19 +1,19 @@
 name: Full CI
-on: 
+on:
   push:
   pull_request:
   workflow_dispatch:
     inputs:
       BEC_WIDGETS_BRANCH:
-        description: 'Branch of BEC Widgets to install'
+        description: "Branch of BEC Widgets to install"
         required: false
         type: string
       BEC_CORE_BRANCH:
-        description: 'Branch of BEC Core to install'
+        description: "Branch of BEC Core to install"
         required: false
         type: string
       OPHYD_DEVICES_BRANCH:
-        description: 'Branch of Ophyd Devices to install'
+        description: "Branch of Ophyd Devices to install"
         required: false
         type: string
 
@@ -23,6 +23,7 @@ concurrency:
 
 permissions:
   pull-requests: write
+  contents: read
 
 jobs:
   check_pr_status:
@@ -33,6 +34,15 @@ jobs:
     if: needs.check_pr_status.outputs.branch-pr == ''
     uses: ./.github/workflows/formatter.yml
 
+  benchmark:
+    needs: [check_pr_status]
+    if: needs.check_pr_status.outputs.branch-pr == ''
+    permissions:
+      contents: write
+      issues: write
+      pull-requests: write
+    uses: ./.github/workflows/benchmark.yml
+
   unit-test:
     needs: [check_pr_status, formatter]
     if: needs.check_pr_status.outputs.branch-pr == ''
@@ -69,9 +79,9 @@ jobs:
     uses: ./.github/workflows/child_repos.yml
     with:
       BEC_CORE_BRANCH: ${{ inputs.BEC_CORE_BRANCH || 'main' }}
-      OPHYD_DEVICES_BRANCH: ${{ inputs.OPHYD_DEVICES_BRANCH || 'main'}} 
+      OPHYD_DEVICES_BRANCH: ${{ inputs.OPHYD_DEVICES_BRANCH || 'main'}}
       BEC_WIDGETS_BRANCH: ${{ inputs.BEC_WIDGETS_BRANCH || github.head_ref || github.sha }}
-  
+
   plugin_repos:
     needs: [check_pr_status, formatter]
     if: needs.check_pr_status.outputs.branch-pr == ''
@@ -81,4 +91,4 @@ jobs:
       BEC_WIDGETS_BRANCH: ${{ inputs.BEC_WIDGETS_BRANCH || github.head_ref || github.sha }}
 
     secrets:
-      GH_READ_TOKEN: ${{ secrets.GH_READ_TOKEN }}
+      GH_READ_TOKEN: ${{ secrets.GH_READ_TOKEN }}

.github/workflows/pytest-matrix.yml

@@ -1,25 +1,25 @@
 name: Run Pytest with different Python versions
-on: 
+on:
   workflow_call:
     inputs:
       pr_number:
-        description: 'Pull request number'
+        description: "Pull request number"
         required: false
         type: number
       BEC_CORE_BRANCH:
-        description: 'Branch of BEC Core to install'
+        description: "Branch of BEC Core to install"
         required: false
-        default: 'main'
+        default: "main"
         type: string
       OPHYD_DEVICES_BRANCH:
-        description: 'Branch of Ophyd Devices to install'
+        description: "Branch of Ophyd Devices to install"
         required: false
-        default: 'main'
+        default: "main"
         type: string
       BEC_WIDGETS_BRANCH:
-        description: 'Branch of BEC Widgets to install'
+        description: "Branch of BEC Widgets to install"
         required: false
-        default: 'main'
+        default: "main"
         type: string
 
 jobs:
@@ -30,15 +30,14 @@ jobs:
         python-version: ["3.11", "3.12", "3.13"]
 
     env:
-      BEC_WIDGETS_BRANCH: main  # Set the branch you want for bec_widgets
-      BEC_CORE_BRANCH: main        # Set the branch you want for bec
-      OPHYD_DEVICES_BRANCH: main   # Set the branch you want for ophyd_devices
+      BEC_WIDGETS_BRANCH: main # Set the branch you want for bec_widgets
+      BEC_CORE_BRANCH: main # Set the branch you want for bec
+      OPHYD_DEVICES_BRANCH: main # Set the branch you want for ophyd_devices
       PROJECT_PATH: ${{ github.repository }}
       QTWEBENGINE_DISABLE_SANDBOX: 1
       QT_QPA_PLATFORM: "offscreen"
 
     steps:
-
       - name: Checkout BEC Widgets
         uses: actions/checkout@v4
         with:
@@ -56,4 +55,4 @@ jobs:
       - name: Run Pytest
         run: |
           pip install pytest pytest-random-order
-          pytest -v --junitxml=report.xml --random-order ./tests/unit_tests
+          pytest -v --junitxml=report.xml --random-order --ignore=tests/unit_tests/benchmarks ./tests/unit_tests

.github/workflows/pytest.yml

@@ -1,32 +1,30 @@
 name: Run Pytest with Coverage
-on: 
+on:
   workflow_call:
     inputs:
       pr_number:
-        description: 'Pull request number'
+        description: "Pull request number"
         required: false
         type: number
       BEC_CORE_BRANCH:
-        description: 'Branch of BEC Core to install'
+        description: "Branch of BEC Core to install"
         required: false
-        default: 'main'
+        default: "main"
         type: string
       OPHYD_DEVICES_BRANCH:
-        description: 'Branch of Ophyd Devices to install'
+        description: "Branch of Ophyd Devices to install"
         required: false
-        default: 'main'
+        default: "main"
         type: string
       BEC_WIDGETS_BRANCH:
-        description: 'Branch of BEC Widgets to install'
+        description: "Branch of BEC Widgets to install"
         required: false
-        default: 'main'
+        default: "main"
         type: string
     secrets:
       CODECOV_TOKEN:
         required: true
 
-
-
 permissions:
   pull-requests: write
 
@@ -55,7 +53,7 @@ jobs:
 
       - name: Run Pytest with Coverage
         id: coverage
-        run: pytest --random-order --cov=bec_widgets --cov-config=pyproject.toml --cov-branch --cov-report=xml --no-cov-on-fail tests/unit_tests/
+        run: pytest --random-order --cov=bec_widgets --cov-config=pyproject.toml --cov-branch --cov-report=xml --no-cov-on-fail --ignore=tests/unit_tests/benchmarks tests/unit_tests/
 
       - name: Upload test artifacts
         uses: actions/upload-artifact@v4
@@ -69,4 +67,4 @@ jobs:
         uses: codecov/codecov-action@v5
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
-          slug: bec-project/bec_widgets
+          slug: bec-project/bec_widgets

CHANGELOG.md

@@ -1,41 +1,6 @@
 # CHANGELOG
 
 
-## v3.6.0 (2026-04-21)
-
-### Bug Fixes
-
-- Change resize mode to interactive
-  ([`a5db2dc`](https://github.com/bec-project/bec_widgets/commit/a5db2dc340f3386e68b300fd4528a44f87cbbf97))
-
-- Small usability changes
-  ([`5a497c3`](https://github.com/bec-project/bec_widgets/commit/5a497c3598c2d8f27916d91d53c646d5d6d3a4a7))
-
-### Features
-
-- Add button/slot to pause/unpause logs
-  ([`23e3644`](https://github.com/bec-project/bec_widgets/commit/23e3644619de958bcfdb8a0b2ee1f7c2ce05b235))
-
-- Add logpanel to menu
-  ([`2e8f43f`](https://github.com/bec-project/bec_widgets/commit/2e8f43fcac581cd1c227308198565d142a1bf276))
-
-- Migrate logpanel to table model/view
-  ([`09bb112`](https://github.com/bec-project/bec_widgets/commit/09bb1121d83bac1f6e4827daa476fbe7cd5b3a80))
-
-
-## v3.5.1 (2026-04-20)
-
-### Bug Fixes
-
-- Don't assume attr exists if we timed out waiting for it
-  ([`f7a1ee4`](https://github.com/bec-project/bec_widgets/commit/f7a1ee49a42c58ba315c8957b45a80d862ffe745))
-
-### Refactoring
-
-- Don't import real widgets in client
-  ([`8e51c1a`](https://github.com/bec-project/bec_widgets/commit/8e51c1adb6a7658c54846794cf97b774cbac2193))
-
-
 ## v3.5.0 (2026-04-14)
 
 ### Bug Fixes

bec_widgets/cli/client.py

@@ -13,7 +13,7 @@ from typing import Literal, Optional
 from bec_lib.logger import bec_logger
 
 from bec_widgets.cli.rpc.rpc_base import RPCBase, rpc_call, rpc_timeout
-from bec_widgets.utils.bec_plugin_helper import get_plugin_client_module
+from bec_widgets.utils.bec_plugin_helper import get_all_plugin_widgets, get_plugin_client_module
 
 logger = bec_logger.logger
 
@@ -62,19 +62,29 @@ _Widgets = {
 
 
 try:
+    _plugin_widgets = get_all_plugin_widgets().as_dict()
     plugin_client = get_plugin_client_module()
+    Widgets = _WidgetsEnumType("Widgets", {name: name for name in _plugin_widgets} | _Widgets)
+
+    if (_overlap := _Widgets.keys() & _plugin_widgets.keys()) != set():
+        for _widget in _overlap:
+            logger.warning(
+                f"Detected duplicate widget {_widget} in plugin repo file: {inspect.getfile(_plugin_widgets[_widget])} !"
+            )
     for plugin_name, plugin_class in inspect.getmembers(plugin_client, inspect.isclass):
         if issubclass(plugin_class, RPCBase) and plugin_class is not RPCBase:
-            if plugin_name not in _Widgets:
-                _Widgets[plugin_name] = plugin_name
             if plugin_name in globals():
+                conflicting_file = (
+                    inspect.getfile(_plugin_widgets[plugin_name])
+                    if plugin_name in _plugin_widgets
+                    else f"{plugin_client}"
+                )
                 logger.warning(
-                    f"Plugin widget {plugin_name} in {plugin_class._IMPORT_MODULE} conflicts with a built-in class!"
+                    f"Plugin widget {plugin_name} from {conflicting_file} conflicts with a built-in class!"
                 )
                 continue
-            else:
+            if plugin_name not in _overlap:
                 globals()[plugin_name] = plugin_class
-        Widgets = _WidgetsEnumType("Widgets", _Widgets)
 except ImportError as e:
     logger.error(f"Failed loading plugins: \n{reduce(add, traceback.format_exception(e))}")
 
@@ -82,8 +92,6 @@ except ImportError as e:
 class AdminView(RPCBase):
     """A view for administrators to change the current active experiment, manage messaging"""
 
-    _IMPORT_MODULE = "bec_widgets.applications.views.admin_view.admin_view"
-
     @rpc_call
     def activate(self) -> "None":
         """
@@ -92,8 +100,6 @@ class AdminView(RPCBase):
 
 
 class AutoUpdates(RPCBase):
-    _IMPORT_MODULE = "bec_widgets.widgets.containers.auto_update.auto_updates"
-
     @property
     @rpc_call
     def enabled(self) -> "bool":
@@ -130,8 +136,6 @@ class AutoUpdates(RPCBase):
 
 
 class AvailableDeviceResources(RPCBase):
-    _IMPORT_MODULE = "bec_widgets.widgets.control.device_manager.components.available_device_resources.available_device_resources"
-
     @rpc_call
     def remove(self):
         """
@@ -152,8 +156,6 @@ class AvailableDeviceResources(RPCBase):
 
 
 class BECDockArea(RPCBase):
-    _IMPORT_MODULE = "bec_widgets.widgets.containers.dock_area.dock_area"
-
     @rpc_call
     def new(
         self,
@@ -389,8 +391,6 @@ class BECDockArea(RPCBase):
 
 
 class BECMainWindow(RPCBase):
-    _IMPORT_MODULE = "bec_widgets.widgets.containers.main_window.main_window"
-
     @rpc_call
     def remove(self):
         """
@@ -413,8 +413,6 @@ class BECMainWindow(RPCBase):
 class BECProgressBar(RPCBase):
     """A custom progress bar with smooth transitions. The displayed text can be customized using a template."""
 
-    _IMPORT_MODULE = "bec_widgets.widgets.progress.bec_progressbar.bec_progressbar"
-
     @rpc_call
     def set_value(self, value):
         """
@@ -488,8 +486,6 @@ class BECProgressBar(RPCBase):
 class BECQueue(RPCBase):
     """Widget to display the BEC queue."""
 
-    _IMPORT_MODULE = "bec_widgets.widgets.services.bec_queue.bec_queue"
-
     @rpc_call
     def remove(self):
         """
@@ -512,8 +508,6 @@ class BECQueue(RPCBase):
 class BECShell(RPCBase):
     """A BecConsole pre-configured to run the BEC shell."""
 
-    _IMPORT_MODULE = "bec_widgets.widgets.editors.bec_console.bec_console"
-
     @rpc_call
     def remove(self):
         """
@@ -536,8 +530,6 @@ class BECShell(RPCBase):
 class BECStatusBox(RPCBase):
     """An autonomous widget to display the status of BEC services."""
 
-    _IMPORT_MODULE = "bec_widgets.widgets.services.bec_status_box.bec_status_box"
-
     @rpc_call
     def get_server_state(self) -> "str":
         """
@@ -573,8 +565,6 @@ class BECStatusBox(RPCBase):
 class BaseROI(RPCBase):
     """Base class for all Region of Interest (ROI) implementations."""
 
-    _IMPORT_MODULE = "bec_widgets.widgets.plots.roi.image_roi"
-
     @property
     @rpc_call
     def label(self) -> "str":
@@ -704,8 +694,6 @@ class BaseROI(RPCBase):
 class BecConsole(RPCBase):
     """A console widget with access to a shared registry of terminals, such that instances can be moved around."""
 
-    _IMPORT_MODULE = "bec_widgets.widgets.editors.bec_console.bec_console"
-
     @rpc_call
     def remove(self):
         """
@@ -728,8 +716,6 @@ class BecConsole(RPCBase):
 class CircularROI(RPCBase):
     """Circular Region of Interest with center/diameter tracking and auto-labeling."""
 
-    _IMPORT_MODULE = "bec_widgets.widgets.plots.roi.image_roi"
-
     @property
     @rpc_call
     def label(self) -> "str":
@@ -857,8 +843,6 @@ class CircularROI(RPCBase):
 
 
 class Curve(RPCBase):
-    _IMPORT_MODULE = "bec_widgets.widgets.plots.waveform.curve"
-
     @rpc_call
     def remove(self):
         """
@@ -1025,8 +1009,6 @@ class Curve(RPCBase):
 class DapComboBox(RPCBase):
     """Editable combobox listing the available DAP models."""
 
-    _IMPORT_MODULE = "bec_widgets.widgets.dap.dap_combo_box.dap_combo_box"
-
     @rpc_call
     def select_y_axis(self, y_axis: str):
         """
@@ -1058,8 +1040,6 @@ class DapComboBox(RPCBase):
 class DeveloperView(RPCBase):
     """A view for users to write scripts and macros and execute them within the application."""
 
-    _IMPORT_MODULE = "bec_widgets.applications.views.developer_view.developer_view"
-
     @rpc_call
     def activate(self) -> "None":
         """
@@ -1070,8 +1050,6 @@ class DeveloperView(RPCBase):
 class DeviceBrowser(RPCBase):
     """DeviceBrowser is a widget that displays all available devices in the current BEC session."""
 
-    _IMPORT_MODULE = "bec_widgets.widgets.services.device_browser.device_browser"
-
     @rpc_call
     def remove(self):
         """
@@ -1094,8 +1072,6 @@ class DeviceBrowser(RPCBase):
 class DeviceInitializationProgressBar(RPCBase):
     """A progress bar that displays the progress of device initialization."""
 
-    _IMPORT_MODULE = "bec_widgets.widgets.progress.device_initialization_progress_bar.device_initialization_progress_bar"
-
     @rpc_call
     def remove(self):
         """
@@ -1118,8 +1094,6 @@ class DeviceInitializationProgressBar(RPCBase):
 class DeviceInputBase(RPCBase):
     """Mixin base class for device input widgets."""
 
-    _IMPORT_MODULE = "bec_widgets.widgets.control.device_input.base_classes.device_input_base"
-
     @rpc_call
     def remove(self):
         """
@@ -1142,8 +1116,6 @@ class DeviceInputBase(RPCBase):
 class DeviceManagerView(RPCBase):
     """A view for users to manage devices within the application."""
 
-    _IMPORT_MODULE = "bec_widgets.applications.views.device_manager_view.device_manager_view"
-
     @rpc_call
     def activate(self) -> "None":
         """
@@ -1154,8 +1126,6 @@ class DeviceManagerView(RPCBase):
 class DockAreaView(RPCBase):
     """Modular dock area view for arranging and managing multiple dockable widgets."""
 
-    _IMPORT_MODULE = "bec_widgets.applications.views.dock_area_view.dock_area_view"
-
     @rpc_call
     def activate(self) -> "None":
         """
@@ -1399,8 +1369,6 @@ class DockAreaView(RPCBase):
 class DockAreaWidget(RPCBase):
     """Lightweight dock area that exposes the core Qt ADS docking helpers without any"""
 
-    _IMPORT_MODULE = "bec_widgets.widgets.containers.dock_area.basic_dock_area"
-
     @rpc_call
     def new(
         self,
@@ -1585,8 +1553,6 @@ class DockAreaWidget(RPCBase):
 class EllipticalROI(RPCBase):
     """Elliptical Region of Interest with centre/width/height tracking and auto-labelling."""
 
-    _IMPORT_MODULE = "bec_widgets.widgets.plots.roi.image_roi"
-
     @property
     @rpc_call
     def label(self) -> "str":
@@ -1709,8 +1675,6 @@ class EllipticalROI(RPCBase):
 class Heatmap(RPCBase):
     """Heatmap widget for visualizing 2d grid data with color mapping for the z-axis."""
 
-    _IMPORT_MODULE = "bec_widgets.widgets.plots.heatmap.heatmap"
-
     @rpc_call
     def remove(self):
         """
@@ -2409,8 +2373,6 @@ class Heatmap(RPCBase):
 class Image(RPCBase):
     """Image widget for displaying 2D data."""
 
-    _IMPORT_MODULE = "bec_widgets.widgets.plots.image.image"
-
     @rpc_call
     def remove(self):
         """
@@ -3022,8 +2984,6 @@ class Image(RPCBase):
 
 
 class ImageItem(RPCBase):
-    _IMPORT_MODULE = "bec_widgets.widgets.plots.image.image_item"
-
     @property
     @rpc_call
     def color_map(self) -> "str":
@@ -3174,8 +3134,6 @@ class ImageItem(RPCBase):
 
 
 class LaunchWindow(RPCBase):
-    _IMPORT_MODULE = "bec_widgets.applications.launch_window"
-
     @rpc_call
     def show_launcher(self):
         """
@@ -3190,38 +3148,33 @@ class LaunchWindow(RPCBase):
 
 
 class LogPanel(RPCBase):
-    """Live display of the BEC logs in a table view."""
-
-    _IMPORT_MODULE = "bec_widgets.widgets.utility.logpanel.logpanel"
+    """Displays a log panel"""
 
     @rpc_call
-    def remove(self):
+    def set_plain_text(self, text: str) -> None:
         """
-        Cleanup the BECConnector
+        Set the plain text of the widget.
+
+        Args:
+            text (str): The text to set.
         """
 
     @rpc_call
-    def attach(self):
-        """
-        None
+    def set_html_text(self, text: str) -> None:
         """
+        Set the HTML text of the widget.
 
-    @rpc_call
-    def detach(self):
-        """
-        Detach the widget from its parent dock widget (if widget is in the dock), making it a floating widget.
+        Args:
+            text (str): The text to set.
         """
 
 
-class Minesweeper(RPCBase):
-    _IMPORT_MODULE = "bec_widgets.widgets.games.minesweeper"
+class Minesweeper(RPCBase): ...
 
 
 class MonacoDock(RPCBase):
     """MonacoDock is a dock widget that contains Monaco editor instances."""
 
-    _IMPORT_MODULE = "bec_widgets.widgets.editors.monaco.monaco_dock"
-
     @rpc_call
     def new(
         self,
@@ -3406,8 +3359,6 @@ class MonacoDock(RPCBase):
 class MonacoWidget(RPCBase):
     """A simple Monaco editor widget"""
 
-    _IMPORT_MODULE = "bec_widgets.widgets.editors.monaco.monaco_widget"
-
     @rpc_call
     def set_text(
         self, text: "str", file_name: "str | None" = None, reset: "bool" = False
@@ -3582,8 +3533,6 @@ class MonacoWidget(RPCBase):
 class MotorMap(RPCBase):
     """Motor map widget for plotting motor positions in 2D including a trace of the last points."""
 
-    _IMPORT_MODULE = "bec_widgets.widgets.plots.motor_map.motor_map"
-
     @rpc_call
     def remove(self):
         """
@@ -4054,8 +4003,6 @@ class MotorMap(RPCBase):
 class MultiWaveform(RPCBase):
     """MultiWaveform widget for displaying multiple waveforms emitted by a single signal."""
 
-    _IMPORT_MODULE = "bec_widgets.widgets.plots.multi_waveform.multi_waveform"
-
     @rpc_call
     def remove(self):
         """
@@ -4515,8 +4462,6 @@ class MultiWaveform(RPCBase):
 class PdfViewerWidget(RPCBase):
     """A widget to display PDF documents with toolbar controls."""
 
-    _IMPORT_MODULE = "bec_widgets.widgets.utility.pdf_viewer.pdf_viewer"
-
     @rpc_call
     def load_pdf(self, file_path: str):
         """
@@ -4648,10 +4593,6 @@ class PdfViewerWidget(RPCBase):
 class PositionIndicator(RPCBase):
     """Display a position within a defined range, e.g. motor limits."""
 
-    _IMPORT_MODULE = (
-        "bec_widgets.widgets.control.device_control.position_indicator.position_indicator"
-    )
-
     @rpc_call
     def set_value(self, position: float):
         """
@@ -4717,10 +4658,6 @@ class PositionIndicator(RPCBase):
 class PositionerBox(RPCBase):
     """Simple Widget to control a positioner in box form"""
 
-    _IMPORT_MODULE = (
-        "bec_widgets.widgets.control.device_control.positioner_box.positioner_box.positioner_box"
-    )
-
     @rpc_call
     def set_positioner(self, positioner: "str | Positioner"):
         """
@@ -4753,8 +4690,6 @@ class PositionerBox(RPCBase):
 class PositionerBox2D(RPCBase):
     """Simple Widget to control two positioners in box form"""
 
-    _IMPORT_MODULE = "bec_widgets.widgets.control.device_control.positioner_box.positioner_box_2d.positioner_box_2d"
-
     @rpc_call
     def set_positioner_hor(self, positioner: "str | Positioner"):
         """
@@ -4824,8 +4759,6 @@ class PositionerBox2D(RPCBase):
 class PositionerControlLine(RPCBase):
     """A widget that controls a single device."""
 
-    _IMPORT_MODULE = "bec_widgets.widgets.control.device_control.positioner_box.positioner_control_line.positioner_control_line"
-
     @rpc_call
     def set_positioner(self, positioner: "str | Positioner"):
         """
@@ -4858,8 +4791,6 @@ class PositionerControlLine(RPCBase):
 class PositionerGroup(RPCBase):
     """Simple Widget to control a positioner in box form"""
 
-    _IMPORT_MODULE = "bec_widgets.widgets.control.device_control.positioner_group.positioner_group"
-
     @rpc_call
     def set_positioners(self, device_names: "str"):
         """
@@ -4891,8 +4822,6 @@ class PositionerGroup(RPCBase):
 class RectangularROI(RPCBase):
     """Defines a rectangular Region of Interest (ROI) with additional functionality."""
 
-    _IMPORT_MODULE = "bec_widgets.widgets.plots.roi.image_roi"
-
     @property
     @rpc_call
     def label(self) -> "str":
@@ -5022,8 +4951,6 @@ class RectangularROI(RPCBase):
 class ResumeButton(RPCBase):
     """A button that continue scan queue."""
 
-    _IMPORT_MODULE = "bec_widgets.widgets.control.buttons.button_resume.button_resume"
-
     @rpc_call
     def remove(self):
         """
@@ -5044,8 +4971,6 @@ class ResumeButton(RPCBase):
 
 
 class Ring(RPCBase):
-    _IMPORT_MODULE = "bec_widgets.widgets.progress.ring_progress_bar.ring"
-
     @rpc_call
     def set_value(self, value: "int | float"):
         """
@@ -5139,8 +5064,6 @@ class Ring(RPCBase):
 
 
 class RingProgressBar(RPCBase):
-    _IMPORT_MODULE = "bec_widgets.widgets.progress.ring_progress_bar.ring_progress_bar"
-
     @rpc_call
     def remove(self):
         """
@@ -5220,14 +5143,12 @@ class RingProgressBar(RPCBase):
 class SBBMonitor(RPCBase):
     """A widget to display the SBB monitor website."""
 
-    _IMPORT_MODULE = "bec_widgets.widgets.editors.sbb_monitor.sbb_monitor"
+    ...
 
 
 class ScanControl(RPCBase):
     """Widget to submit new scans to the queue."""
 
-    _IMPORT_MODULE = "bec_widgets.widgets.control.scan_control.scan_control"
-
     @rpc_call
     def attach(self):
         """
@@ -5251,8 +5172,6 @@ class ScanControl(RPCBase):
 class ScanProgressBar(RPCBase):
     """Widget to display a progress bar that is hooked up to the scan progress of a scan."""
 
-    _IMPORT_MODULE = "bec_widgets.widgets.progress.scan_progressbar.scan_progressbar"
-
     @rpc_call
     def remove(self):
         """
@@ -5275,8 +5194,6 @@ class ScanProgressBar(RPCBase):
 class ScatterCurve(RPCBase):
     """Scatter curve item for the scatter waveform widget."""
 
-    _IMPORT_MODULE = "bec_widgets.widgets.plots.scatter_waveform.scatter_curve"
-
     @property
     @rpc_call
     def color_map(self) -> "str":
@@ -5286,8 +5203,6 @@ class ScatterCurve(RPCBase):
 
 
 class ScatterWaveform(RPCBase):
-    _IMPORT_MODULE = "bec_widgets.widgets.plots.scatter_waveform.scatter_waveform"
-
     @rpc_call
     def remove(self):
         """
@@ -5755,8 +5670,6 @@ class ScatterWaveform(RPCBase):
 
 
 class SignalLabel(RPCBase):
-    _IMPORT_MODULE = "bec_widgets.widgets.utility.signal_label.signal_label"
-
     @property
     @rpc_call
     def custom_label(self) -> "str":
@@ -5901,8 +5814,6 @@ class SignalLabel(RPCBase):
 class TextBox(RPCBase):
     """A widget that displays text in plain and HTML format"""
 
-    _IMPORT_MODULE = "bec_widgets.widgets.editors.text_box.text_box"
-
     @rpc_call
     def set_plain_text(self, text: str) -> None:
         """
@@ -5925,8 +5836,6 @@ class TextBox(RPCBase):
 class ViewBase(RPCBase):
     """Wrapper for a content widget used inside the main app's stacked view."""
 
-    _IMPORT_MODULE = "bec_widgets.applications.views.view"
-
     @rpc_call
     def activate(self) -> "None":
         """
@@ -5937,8 +5846,6 @@ class ViewBase(RPCBase):
 class Waveform(RPCBase):
     """Widget for plotting waveforms."""
 
-    _IMPORT_MODULE = "bec_widgets.widgets.plots.waveform.waveform"
-
     @rpc_call
     def remove(self):
         """
@@ -6517,8 +6424,6 @@ class Waveform(RPCBase):
 
 
 class WaveformViewInline(RPCBase):
-    _IMPORT_MODULE = "bec_widgets.applications.views.view"
-
     @rpc_call
     def activate(self) -> "None":
         """
@@ -6527,8 +6432,6 @@ class WaveformViewInline(RPCBase):
 
 
 class WaveformViewPopup(RPCBase):
-    _IMPORT_MODULE = "bec_widgets.applications.views.view"
-
     @rpc_call
     def activate(self) -> "None":
         """
@@ -6539,8 +6442,6 @@ class WaveformViewPopup(RPCBase):
 class WebsiteWidget(RPCBase):
     """A simple widget to display a website"""
 
-    _IMPORT_MODULE = "bec_widgets.widgets.editors.website.website"
-
     @rpc_call
     def set_url(self, url: str) -> None:
         """

bec_widgets/cli/generate_cli.py

@@ -7,7 +7,6 @@ import inspect
 import os
 import sys
 from pathlib import Path
-from typing import get_overloads
 
 import black
 import isort
@@ -19,6 +18,20 @@ from bec_widgets.utils.plugin_utils import BECClassContainer, get_custom_classes
 
 logger = bec_logger.logger
 
+if sys.version_info >= (3, 11):
+    from typing import get_overloads
+else:
+    print(
+        "Python version is less than 3.11, using dummy function for get_overloads. "
+        "If you want to use the real function 'typing.get_overloads()', please use Python 3.11 or later."
+    )
+
+    def get_overloads(_obj):
+        """
+        Dummy function for Python versions before 3.11.
+        """
+        return []
+
 
 class ClientGenerator:
     def __init__(self, base=False):
@@ -41,7 +54,7 @@ from __future__ import annotations
 from bec_lib.logger import bec_logger
 
 from bec_widgets.cli.rpc.rpc_base import RPCBase, rpc_call, rpc_timeout
-{"from bec_widgets.utils.bec_plugin_helper import get_plugin_client_module" if self._base else ""}
+{"from bec_widgets.utils.bec_plugin_helper import get_all_plugin_widgets, get_plugin_client_module" if self._base else ""}
 
 logger = bec_logger.logger
 
@@ -98,19 +111,27 @@ _Widgets = {
             self.content += """
 
 try:
+    _plugin_widgets = get_all_plugin_widgets().as_dict()
     plugin_client = get_plugin_client_module()
+    Widgets = _WidgetsEnumType("Widgets", {name: name for name in _plugin_widgets} | _Widgets)
+
+    if (_overlap := _Widgets.keys() & _plugin_widgets.keys()) != set():
+        for _widget in _overlap:
+            logger.warning(f"Detected duplicate widget {_widget} in plugin repo file: {inspect.getfile(_plugin_widgets[_widget])} !")
     for plugin_name, plugin_class in inspect.getmembers(plugin_client, inspect.isclass):
         if issubclass(plugin_class, RPCBase) and plugin_class is not RPCBase:
-            if plugin_name not in _Widgets:
-                _Widgets[plugin_name] = plugin_name
             if plugin_name in globals():
+                conflicting_file = (
+                    inspect.getfile(_plugin_widgets[plugin_name])
+                    if plugin_name in _plugin_widgets
+                    else f"{plugin_client}"
+                )
                 logger.warning(
-                    f"Plugin widget {plugin_name} in {plugin_class._IMPORT_MODULE} conflicts with a built-in class!"
+                    f"Plugin widget {plugin_name} from {conflicting_file} conflicts with a built-in class!"
                 )
                 continue
-            else:
+            if plugin_name not in _overlap:
                 globals()[plugin_name] = plugin_class
-        Widgets = _WidgetsEnumType("Widgets", _Widgets)
 except ImportError as e:
     logger.error(f"Failed loading plugins: \\n{reduce(add, traceback.format_exception(e))}")
 """
@@ -125,8 +146,12 @@ except ImportError as e:
 
         class_name = cls.__name__
 
-        self.content += f"""
-class {class_name}(RPCBase):\n"""
+        if class_name == "BECDockArea":
+            self.content += f"""
+class {class_name}(RPCBase):"""
+        else:
+            self.content += f"""
+class {class_name}(RPCBase):"""
 
         if cls.__doc__:
             # We only want the first line of the docstring
@@ -137,9 +162,13 @@ class {class_name}(RPCBase):\n"""
             else:
                 class_docs = cls.__doc__.split("\n")[1]
             self.content += f"""
-    \"\"\"{class_docs}\"\"\"\n"""
+    \"\"\"{class_docs}\"\"\"
+    """
         user_access_entries = self._get_user_access_entries(cls)
-        self.content += f'    _IMPORT_MODULE="{cls.__module__}"\n'
+        if not user_access_entries:
+            self.content += """...
+    """
+
         for method_entry in user_access_entries:
             method, obj, is_property_setter = self._resolve_method_object(cls, method_entry)
             if obj is None:

bec_widgets/widgets/containers/dock_area/dock_area.py

@@ -79,7 +79,7 @@ from bec_widgets.widgets.plots.waveform.waveform import Waveform
 from bec_widgets.widgets.progress.ring_progress_bar.ring_progress_bar import RingProgressBar
 from bec_widgets.widgets.services.bec_queue.bec_queue import BECQueue
 from bec_widgets.widgets.services.bec_status_box.bec_status_box import BECStatusBox
-from bec_widgets.widgets.utility.logpanel.logpanel import LogPanel
+from bec_widgets.widgets.utility.logpanel import LogPanel
 from bec_widgets.widgets.utility.visual.dark_mode_button.dark_mode_button import DarkModeButton
 
 logger = bec_logger.logger
@@ -376,7 +376,6 @@ class BECDockArea(DockAreaWidget):
             "bec_shell": (BECShell.ICON_NAME, "Add BEC Shell", "BECShell"),
             "log_panel": (LogPanel.ICON_NAME, "Add LogPanel - Disabled", "LogPanel"),
             "sbb_monitor": ("train", "Add SBB Monitor", "SBBMonitor"),
-            "log_panel": (LogPanel.ICON_NAME, "Add LogPanel", "LogPanel"),
         }
 
         # Create expandable menu actions (original behavior)
@@ -488,7 +487,9 @@ class BECDockArea(DockAreaWidget):
             # first two items not needed for this part
             for key, (_, _, widget_type) in mapping.items():
                 act = menu.actions[key].action
-                if key == "terminal":
+                if widget_type == "LogPanel":
+                    act.setEnabled(False)  # keep disabled per issue #644
+                elif key == "terminal":
                     act.triggered.connect(
                         lambda _, t=widget_type: self.new(widget=t, closable=True, startup_cmd=None)
                     )
@@ -509,7 +510,10 @@ class BECDockArea(DockAreaWidget):
             for action_id, (_, _, widget_type) in mapping.items():
                 flat_action_id = f"flat_{action_id}"
                 flat_action = self.toolbar.components.get_action(flat_action_id).action
-                flat_action.triggered.connect(lambda _, t=widget_type: self.new(t))
+                if widget_type == "LogPanel":
+                    flat_action.setEnabled(False)  # keep disabled per issue #644
+                else:
+                    flat_action.triggered.connect(lambda _, t=widget_type: self.new(t))
 
         _connect_flat_actions(self._ACTION_MAPPINGS["menu_plots"])
         _connect_flat_actions(self._ACTION_MAPPINGS["menu_devices"])

bec_widgets/widgets/utility/logpanel/_util.py

@@ -0,0 +1,58 @@
+"""Utilities for filtering and formatting in the LogPanel"""
+
+from __future__ import annotations
+
+import re
+from collections import deque
+from typing import Callable, Iterator
+
+from bec_lib.logger import LogLevel
+from bec_lib.messages import LogMessage
+from qtpy.QtCore import QDateTime
+
+LinesHtmlFormatter = Callable[[deque[LogMessage]], Iterator[str]]
+LineFormatter = Callable[[LogMessage], str]
+LineFilter = Callable[[LogMessage], bool] | None
+
+ANSI_ESCAPE_REGEX = re.compile(r"\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])")
+
+
+def replace_escapes(s: str):
+    s = ANSI_ESCAPE_REGEX.sub("", s)
+    return s.replace(" ", "&nbsp;").replace("\n", "<br />").replace("\t", "    ")
+
+
+def level_filter(msg: LogMessage, thresh: int):
+    return LogLevel[msg.content["log_type"].upper()].value >= thresh
+
+
+def noop_format(line: LogMessage):
+    _textline = line.log_msg if isinstance(line.log_msg, str) else line.log_msg["text"]
+    return replace_escapes(_textline.strip()) + "<br />"
+
+
+def simple_color_format(line: LogMessage, colors: dict[LogLevel, str]):
+    color = colors.get(LogLevel[line.content["log_type"].upper()]) or colors[LogLevel.INFO]
+    return f'<font color="{color}">{noop_format(line)}</font>'
+
+
+def create_formatter(line_format: LineFormatter, line_filter: LineFilter) -> LinesHtmlFormatter:
+    def _formatter(data: deque[LogMessage]):
+        if line_filter is not None:
+            return (line_format(line) for line in data if line_filter(line))
+        else:
+            return (line_format(line) for line in data)
+
+    return _formatter
+
+
+def log_txt(line):
+    return line.log_msg if isinstance(line.log_msg, str) else line.log_msg["text"]
+
+
+def log_time(line):
+    return QDateTime.fromMSecsSinceEpoch(int(line.log_msg["record"]["time"]["timestamp"] * 1000))
+
+
+def log_svc(line):
+    return line.log_msg["service_name"]

bec_widgets/widgets/utility/logpanel/log_panel_plugin.py

@@ -30,7 +30,7 @@ class LogPanelPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
         return DOM_XML
 
     def group(self):
-        return ""
+        return "BEC Services"
 
     def icon(self):
         return designer_material_icon(LogPanel.ICON_NAME)
@@ -51,7 +51,7 @@ class LogPanelPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
         return "LogPanel"
 
     def toolTip(self):
-        return "LogPanel"
+        return "Displays a log panel"
 
     def whatsThis(self):
         return self.toolTip()

bec_widgets/widgets/utility/logpanel/logpanel.py

@@ -2,31 +2,21 @@
 
 from __future__ import annotations
 
+import operator
 import os
+import re
 from collections import deque
-from dataclasses import dataclass
-from functools import partial
-from typing import Iterable, Literal
+from functools import partial, reduce
+from re import Pattern
+from typing import TYPE_CHECKING, Literal
 
 from bec_lib.client import BECClient
 from bec_lib.endpoints import MessageEndpoints
 from bec_lib.logger import LogLevel, bec_logger
 from bec_lib.messages import LogMessage, StatusMessage
-from bec_qthemes import material_icon
-from qtpy.QtCore import Signal  # type: ignore
-from qtpy.QtCore import (
-    QAbstractTableModel,
-    QCoreApplication,
-    QDateTime,
-    QModelIndex,
-    QObject,
-    QPersistentModelIndex,
-    QSize,
-    QSortFilterProxyModel,
-    Qt,
-    QTimer,
-)
-from qtpy.QtGui import QColor
+from pyqtgraph import SignalProxy
+from qtpy.QtCore import QDateTime, QObject, Qt, Signal
+from qtpy.QtGui import QFont
 from qtpy.QtWidgets import (
     QApplication,
     QCheckBox,
@@ -35,414 +25,204 @@ from qtpy.QtWidgets import (
     QDialog,
     QGridLayout,
     QHBoxLayout,
-    QHeaderView,
     QLabel,
     QLineEdit,
     QPushButton,
-    QSizePolicy,
-    QTableView,
-    QToolButton,
+    QScrollArea,
+    QTextEdit,
     QVBoxLayout,
     QWidget,
 )
-from thefuzz import fuzz
 
 from bec_widgets.utils.bec_connector import BECConnector
-from bec_widgets.utils.bec_widget import BECWidget
-from bec_widgets.utils.colors import apply_theme
+from bec_widgets.utils.colors import apply_theme, get_theme_palette
 from bec_widgets.utils.error_popups import SafeSlot
+from bec_widgets.widgets.editors.text_box.text_box import TextBox
+from bec_widgets.widgets.services.bec_status_box.bec_status_box import BECServiceStatusMixin
+from bec_widgets.widgets.utility.logpanel._util import (
+    LineFilter,
+    LineFormatter,
+    LinesHtmlFormatter,
+    create_formatter,
+    level_filter,
+    log_svc,
+    log_time,
+    log_txt,
+    noop_format,
+    simple_color_format,
+)
+
+if TYPE_CHECKING:  # pragma: no cover
+    from qtpy.QtCore import SignalInstance
 
 logger = bec_logger.logger
 
 MODULE_PATH = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
 
-_DEFAULT_LOG_COLORS = {
-    LogLevel.INFO.name: QColor("#FFFFFF"),
-    LogLevel.SUCCESS.name: QColor("#00FF00"),
-    LogLevel.WARNING.name: QColor("#FFCC00"),
-    LogLevel.ERROR.name: QColor("#FF0000"),
-    LogLevel.DEBUG.name: QColor("#0000CC"),
+# TODO: improve log color handling
+DEFAULT_LOG_COLORS = {
+    LogLevel.INFO: "#FFFFFF",
+    LogLevel.SUCCESS: "#00FF00",
+    LogLevel.WARNING: "#FFCC00",
+    LogLevel.ERROR: "#FF0000",
+    LogLevel.DEBUG: "#0000CC",
 }
 
 
-@dataclass(frozen=True)
-class _Constants:
-    FUZZ_THRESHOLD = 80
-    UPDATE_INTERVAL_MS = 200
-    headers = ["level", "timestamp", "service_name", "message", "function"]
-
-
-_CONST = _Constants()
-
-
-class TimestampUpdate:
-    def __init__(self, value: QDateTime | None, update_type: Literal["start", "end"]) -> None:
-        self.value = value
-        self.update_type = update_type
-
-
 class BecLogsQueue(BECConnector, QObject):
     """Manages getting logs from BEC Redis and formatting them for display"""
 
     RPC = False
-    new_messages = Signal()
-    paused = Signal(bool)
-    _instance: BecLogsQueue | None = None
+    new_message = Signal()
 
-    @classmethod
-    def instance(cls):
-        if cls._instance is None:
-            cls._instance = cls(QCoreApplication.instance())
-        return cls._instance
-
-    def __init__(self, parent: QObject | None, maxlen: int = 2500, **kwargs) -> None:
-        if BecLogsQueue._instance:
-            raise RuntimeError("Create no more than one BecLogsQueue - use BecLogsQueue.instance()")
+    def __init__(
+        self,
+        parent: QObject | None,
+        maxlen: int = 1000,
+        line_formatter: LineFormatter = noop_format,
+        **kwargs,
+    ) -> None:
         super().__init__(parent=parent, **kwargs)
+        self._timestamp_start: QDateTime | None = None
+        self._timestamp_end: QDateTime | None = None
         self._max_length = maxlen
-        self._paused = False
-        self._data = deque(
-            (
-                item["data"]
-                for item in self.bec_dispatcher.client.connector.xread(
-                    MessageEndpoints.log(), count=self._max_length, id="0"
-                )
-            ),
-            maxlen=self._max_length,
-        )
-        self._incoming: deque[LogMessage] = deque([], maxlen=self._max_length)
+        self._data: deque[LogMessage] = deque([], self._max_length)
+        self._display_queue: deque[str] = deque([], self._max_length)
+        self._log_level: str | None = None
+        self._search_query: Pattern | str | None = None
+        self._selected_services: set[str] | None = None
+        self._set_formatter_and_update_filter(line_formatter)
+        # instance attribute still accessible after c++ object is deleted, so the callback can be unregistered
         self.bec_dispatcher.connect_slot(self._process_incoming_log_msg, MessageEndpoints.log())
 
-        self._update_timer = QTimer(self, interval=_CONST.UPDATE_INTERVAL_MS)
-        self._update_timer.timeout.connect(self._proc_update)
-        QCoreApplication.instance().aboutToQuit.connect(self.cleanup)  # type: ignore
-        self._update_timer.start()
-
-    def __len__(self):
-        return len(self._data)
-
-    @SafeSlot()
-    def toggle_pause(self):
-        self._paused = not self._paused
-        self.paused.emit(self._paused)
-
-    def row_data(self, index: int) -> LogMessage | None:
-        if index < 0 or index > (len(self._data) - 1):
-            return None
-        return self._data[index]
-
-    def cell_data(self, row: int, key: str):
-        if key == "level":
-            return self._data[row].log_type.upper()
-
-        msg_item = self._data[row].log_msg
-        if isinstance(msg_item, str):
-            return msg_item
-        if key == "service_name":
-            return msg_item.get(key)
-        elif key in ["service_name", "function", "message"]:
-            return msg_item.get("record", {}).get(key)
-        elif key == "timestamp":
-            return msg_item.get("record", {}).get("time", {}).get("repr")
-
-    def log_timestamp(self, row: int) -> float:
-        msg_item = self._data[row].log_msg
-        if isinstance(msg_item, str):
-            return 0
-        return msg_item.get("record", {}).get("time", {}).get("timestamp")
-
     def cleanup(self, *_):
         """Stop listening to the Redis log stream"""
         self.bec_dispatcher.disconnect_slot(
             self._process_incoming_log_msg, [MessageEndpoints.log()]
         )
-        self._update_timer.stop()
-        BecLogsQueue._instance = None
 
     @SafeSlot(verify_sender=True)
     def _process_incoming_log_msg(self, msg: dict, _metadata: dict):
         try:
             _msg = LogMessage(**msg)
-            self._incoming.append(_msg)
+            self._data.append(_msg)
+            if self.filter is None or self.filter(_msg):
+                self._display_queue.append(self._line_formatter(_msg))
+                self.new_message.emit()
         except Exception as e:
             if "Internal C++ object (BecLogsQueue) already deleted." in e.args:
                 return
             logger.warning(f"Error in LogPanel incoming message callback: {e}")
 
-    @SafeSlot(verify_sender=True)
-    def _proc_update(self):
-        if self._paused or len(self._incoming) == 0:
-            return
-        self._data.extend(self._incoming)
-        self._incoming.clear()
-        self.new_messages.emit()
+    def _set_formatter_and_update_filter(self, line_formatter: LineFormatter = noop_format):
+        self._line_formatter: LineFormatter = line_formatter
+        self._queue_formatter: LinesHtmlFormatter = create_formatter(
+            self._line_formatter, self.filter
+        )
 
+    def _combine_filters(self, *args: LineFilter):
+        return lambda msg: reduce(operator.and_, [filt(msg) for filt in args if filt is not None])
 
-class BecLogsTableModel(QAbstractTableModel):
-    def __init__(self, parent: QWidget | None = None):
-        super().__init__(parent)
-        self.log_queue = BecLogsQueue.instance()
-        self.log_queue.new_messages.connect(self.handle_new_messages)
-        self._headers = _CONST.headers
-
-    def rowCount(self, parent: QModelIndex | QPersistentModelIndex = QModelIndex()) -> int:
-        return len(self.log_queue)
-
-    def columnCount(self, parent: QModelIndex | QPersistentModelIndex = QModelIndex()) -> int:
-        return len(self._headers)
-
-    def headerData(self, section, orientation, role=int(Qt.ItemDataRole.DisplayRole)):
-        if role == Qt.ItemDataRole.DisplayRole and orientation == Qt.Orientation.Horizontal:
-            return self._headers[section]
-        return None
-
-    def get_row_data(self, index: QModelIndex) -> LogMessage | None:
-        """Return the row data for the given index."""
-        if not index.isValid():
+    def _create_re_filter(self) -> LineFilter:
+        if self._search_query is None:
             return None
-        return self.log_queue.row_data(index.row())
+        elif isinstance(self._search_query, str):
+            return lambda line: self._search_query in log_txt(line)
+        return lambda line: self._search_query.match(log_txt(line)) is not None
 
-    def timestamp(self, row: int):
-        return QDateTime.fromMSecsSinceEpoch(int(self.log_queue.log_timestamp(row) * 1000))
+    def _create_service_filter(self):
+        return (
+            lambda line: self._selected_services is None or log_svc(line) in self._selected_services
+        )
 
-    def data(self, index, role=int(Qt.ItemDataRole.DisplayRole)):
-        """Return data for the given index and role."""
-        if not index.isValid():
+    def _create_timestamp_filter(self) -> LineFilter:
+        s, e = self._timestamp_start, self._timestamp_end
+        if s is e is None:
+            return lambda msg: True
+
+        def _time_filter(msg):
+            msg_time = log_time(msg)
+            if s is None:
+                return msg_time <= e
+            if e is None:
+                return s <= msg_time
+            return s <= msg_time <= e
+
+        return _time_filter
+
+    @property
+    def filter(self) -> LineFilter:
+        """A function which filters a log message based on all applied criteria"""
+        thresh = LogLevel[self._log_level].value if self._log_level is not None else 0
+        return self._combine_filters(
+            partial(level_filter, thresh=thresh),
+            self._create_re_filter(),
+            self._create_timestamp_filter(),
+            self._create_service_filter(),
+        )
+
+    def update_level_filter(self, level: str):
+        """Change the log-level of the level filter"""
+        if level not in [l.name for l in LogLevel]:
+            logger.error(f"Logging level {level} unrecognized for filter!")
             return
-        if role in [Qt.ItemDataRole.DisplayRole, Qt.ItemDataRole.ToolTipRole]:
-            return self.log_queue.cell_data(index.row(), self._headers[index.column()])
-        if role in [Qt.ItemDataRole.ForegroundRole]:
-            return self._map_log_level_color(self.log_queue.cell_data(index.row(), "level"))
+        self._log_level = level
+        self._set_formatter_and_update_filter(self._line_formatter)
 
-    def _map_log_level_color(self, data):
-        return _DEFAULT_LOG_COLORS.get(data)
+    def update_search_filter(self, search_query: Pattern | str | None = None):
+        """Change the string or regex to filter against"""
+        self._search_query = search_query
+        self._set_formatter_and_update_filter(self._line_formatter)
 
-    def handle_new_messages(self):
-        self.dataChanged.emit(
-            self.index(0, 0), self.index(self.rowCount() - 1, self.columnCount() - 1)
+    def update_time_filter(self, start: QDateTime | None, end: QDateTime | None):
+        """Change the start and/or end times to filter against"""
+        self._timestamp_start = start
+        self._timestamp_end = end
+        self._set_formatter_and_update_filter(self._line_formatter)
+
+    def update_service_filter(self, services: set[str]):
+        """Change the selected services to display"""
+        self._selected_services = services
+        self._set_formatter_and_update_filter(self._line_formatter)
+
+    def update_line_formatter(self, line_formatter: LineFormatter):
+        """Update the formatter"""
+        self._set_formatter_and_update_filter(line_formatter)
+
+    def display_all(self) -> str:
+        """Return formatted output for all log messages"""
+        return "\n".join(self._queue_formatter(self._data.copy()))
+
+    def format_new(self):
+        """Return formatted output for the display queue"""
+        res = "\n".join(self._display_queue)
+        self._display_queue = deque([], self._max_length)
+        return res
+
+    def clear_logs(self):
+        """Clear the cache and display queue"""
+        self._data = deque([])
+        self._display_queue = deque([])
+
+    def fetch_history(self):
+        """Fetch all available messages from Redis"""
+        self._data = deque(
+            item["data"]
+            for item in self.bec_dispatcher.client.connector.xread(
+                MessageEndpoints.log().endpoint, from_start=True, count=self._max_length
+            )
         )
 
-
-class LogMsgProxyModel(QSortFilterProxyModel):
-    show_service_column = Signal(bool)
-
-    def __init__(
-        self,
-        parent=None,
-        service_filter: set[str] | None = None,
-        level_filter: LogLevel | None = None,
-    ):
-        super().__init__(parent)
-        self._service_filter = service_filter or set()
-        self._level_filter: LogLevel | None = level_filter
-        self._filter_text: str = ""
-        self._fuzzy_search: bool = False
-        self._time_filter_start: QDateTime | None = None
-        self._time_filter_end: QDateTime | None = None
-
-    def get_row_data(self, rows: Iterable[QModelIndex]) -> Iterable[LogMessage | None]:
-        return (self.sourceModel().get_row_data(self.mapToSource(idx)) for idx in rows)
-
-    def sourceModel(self) -> BecLogsTableModel:
-        return super().sourceModel()  # type: ignore
-
-    @SafeSlot(int, int)
-    def refresh(self, *_):
-        self.invalidateRowsFilter()
-
-    @SafeSlot(None)
-    @SafeSlot(set)
-    def update_service_filter(self, filter: set[str]):
-        """Filter to the selected services (show any service in the provided set)
-
-        Args:
-            filter (set[str] | None): set of services for which to show logs"""
-        self._service_filter = filter
-        self.show_service_column.emit(len(filter) != 1)
-        self.invalidateRowsFilter()
-
-    @SafeSlot(None)
-    @SafeSlot(LogLevel)
-    def update_level_filter(self, filter: LogLevel | None):
-        """Filter to the selected log level
-
-        Args:
-            filter (str | None): lowest log level to show"""
-        self._level_filter = filter
-        self.invalidateRowsFilter()
-
-    @SafeSlot(str)
-    def update_filter_text(self, filter: str):
-        """Filter messages based on text
-
-        Args:
-            filter (str | None): set of services for which to show logs"""
-        self._filter_text = filter
-        self.invalidateRowsFilter()
-
-    @SafeSlot(bool)
-    def update_fuzzy(self, state: bool):
-        """Set text filter to fuzzy search or not
-
-        Args:
-            state (bool): fuzzy search on"""
-        self._fuzzy_search = state
-        self.invalidateRowsFilter()
-
-    @SafeSlot(TimestampUpdate)
-    def update_timestamp(self, update: TimestampUpdate):
-        if update.update_type == "start":
-            self._time_filter_start = update.value
-        else:
-            self._time_filter_end = update.value
-        self.invalidateRowsFilter()
-
-    def filterAcceptsRow(self, source_row: int, source_parent) -> bool:
-        # No service filter, and no filter text, display everything
-        possible_filters = [
-            self._service_filter,
-            self._level_filter,
-            self._filter_text,
-            self._time_filter_start,
-            self._time_filter_end,
-        ]
-        if not any(map(bool, possible_filters)):
-            return True
-        model = self.sourceModel()
-        # Filter out services
-        if self._service_filter:
-            col = _CONST.headers.index("service_name")
-            if model.data(model.index(source_row, col, source_parent)) not in self._service_filter:
-                return False
-        # Filter out levels
-        if self._level_filter:
-            col = _CONST.headers.index("level")
-            level: str = model.data(model.index(source_row, col, source_parent))  # type: ignore
-            if LogLevel[level] < self._level_filter:
-                return False
-        # Filter time
-        if self._time_filter_start:
-            if model.timestamp(source_row) < self._time_filter_start:
-                return False
-        if self._time_filter_end:
-            if model.timestamp(source_row) > self._time_filter_end:
-                return False
-        # Filter message text - must go last because this can return True
-        if self._filter_text:
-            col = _CONST.headers.index("message")
-            msg: str = model.data(model.index(source_row, col, source_parent)).lower()  # type: ignore
-            if self._fuzzy_search:
-                return fuzz.partial_ratio(self._filter_text.lower(), msg) >= _CONST.FUZZ_THRESHOLD
-            else:
-                return self._filter_text.lower() in msg.lower()
-        return True
-
-
-class BecLogTableView(QTableView):
-    def __init__(self, *args, max_message_width: int = 1000, **kwargs) -> None:
-        super().__init__(*args, **kwargs)
-        header = QHeaderView(Qt.Orientation.Horizontal, parent=self)
-        header.setSectionResizeMode(QHeaderView.ResizeMode.Interactive)
-        header.setStretchLastSection(True)
-        header.setMaximumSectionSize(max_message_width)
-        self.setHorizontalHeader(header)
-
-    def model(self) -> LogMsgProxyModel:
-        return super().model()  # type: ignore
-
-
-class LogPanel(BECWidget, QWidget):
-    """Live display of the BEC logs in a table view."""
-
-    PLUGIN = True
-    ICON_NAME = "browse_activity"
-
-    def __init__(
-        self,
-        parent: QWidget | None = None,
-        max_message_width: int = 1000,
-        show_toolbar: bool = True,
-        service_filter: set[str] | None = None,
-        level_filter: LogLevel | None = None,
-        **kwargs,
-    ) -> None:
-        super().__init__(parent=parent, **kwargs)
-        self._setup_models(service_filter=service_filter, level_filter=level_filter)
-        self._layout = QVBoxLayout()
-        self.setLayout(self._layout)
-        if show_toolbar:
-            self._setup_toolbar(client=self.client)
-        self._setup_table_view(max_message_width=max_message_width)
-        self._update_service_filter(service_filter or set())
-        if show_toolbar:
-            self._connect_toolbar()
-        self._proxy.show_service_column.connect(self._show_service_column)
-        colors = QApplication.instance().theme.accent_colors  # type: ignore
-        dict_colors = QApplication.instance().theme.colors  # type: ignore
-        _DEFAULT_LOG_COLORS.update(
-            {
-                LogLevel.INFO.name: dict_colors["FG"],
-                LogLevel.SUCCESS.name: colors.success,
-                LogLevel.WARNING.name: colors.warning,
-                LogLevel.ERROR.name: colors.emergency,
-                LogLevel.DEBUG.name: dict_colors["BORDER"],
-            }
-        )
-        self._table.scrollToBottom()
-
-    def _setup_models(self, service_filter: set[str] | None, level_filter: LogLevel | None):
-        self._model = BecLogsTableModel(parent=self)
-        self._proxy = LogMsgProxyModel(
-            parent=self, service_filter=service_filter, level_filter=level_filter
-        )
-        self._proxy.setSourceModel(self._model)
-        self._model.log_queue.new_messages.connect(self._proxy.refresh)
-
-    def _setup_table_view(self, max_message_width: int) -> None:
-        """Setup the table view."""
-        self._table = BecLogTableView(self, max_message_width=max_message_width)
-        self._table.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding)
-        self._layout.addWidget(self._table)
-        self._table.setModel(self._proxy)
-        self._table.setHorizontalScrollMode(QTableView.ScrollMode.ScrollPerPixel)
-        self._table.setTextElideMode(Qt.TextElideMode.ElideRight)
-        self._table.resizeColumnsToContents()
-
-    def _setup_toolbar(self, client: BECClient):
-        self._toolbar = LogPanelToolbar(self, client)
-        self._layout.addWidget(self._toolbar)
-
-    def _connect_toolbar(self):
-        self._toolbar.services_selected.connect(self._proxy.update_service_filter)
-        self._toolbar.search_textbox.textChanged.connect(self._proxy.update_filter_text)
-        self._toolbar.level_changed.connect(self._proxy.update_level_filter)
-        self._toolbar.fuzzy_changed.connect(self._proxy.update_fuzzy)
-        self._toolbar.timestamp_update.connect(self._proxy.update_timestamp)
-        self._toolbar.pause_button.clicked.connect(self._model.log_queue.toggle_pause)
-        self._model.log_queue.paused.connect(self._toolbar._update_pause_button_icon)
-
-    def _update_service_filter(self, filter: set[str]):
-        self._service_filter = filter
-        self._proxy.update_service_filter(filter)
-        self._table.setColumnHidden(
-            _CONST.headers.index("service_name"), len(self._service_filter) == 1
-        )
-
-    @SafeSlot(bool)
-    def _show_service_column(self, show: bool):
-        self._table.setColumnHidden(_CONST.headers.index("service_name"), not show)
-
-    def sizeHint(self) -> QSize:
-        return QSize(600, 300)
+    def unique_service_names_from_history(self) -> set[str]:
+        """Go through the log history to determine active service names"""
+        return set(msg.log_msg["service_name"] for msg in self._data)
 
 
 class LogPanelToolbar(QWidget):
-    services_selected = Signal(set)
-    level_changed = Signal(LogLevel)
-    fuzzy_changed = Signal(bool)
-    timestamp_update = Signal(TimestampUpdate)
 
-    def __init__(self, parent: QWidget | None = None, client: BECClient | None = None) -> None:
+    services_selected: SignalInstance = Signal(set)
+
+    def __init__(self, parent: QWidget | None = None) -> None:
         """A toolbar for the logpanel, mainly used for managing the states of filters"""
         super().__init__(parent)
 
@@ -451,69 +231,51 @@ class LogPanelToolbar(QWidget):
         self._timestamp_end: QDateTime | None = None
 
         self._unique_service_names: set[str] = set()
-        self._services_selected: set[str] = set()
+        self._services_selected: set[str] | None = None
 
-        self._layout = QHBoxLayout(self)
+        self.layout = QHBoxLayout(self)  # type: ignore
 
-        if client is not None:
-            self.client = client
-            self.service_choice_button = QPushButton("Select services", self)
-            self._layout.addWidget(self.service_choice_button)
-            self.service_choice_button.clicked.connect(self._open_service_filter_dialog)
-            self.service_list_update(self.client.service_status)
-            self._services_selected = self._unique_service_names
+        self.service_choice_button = QPushButton("Select services", self)
+        self.layout.addWidget(self.service_choice_button)
+        self.service_choice_button.clicked.connect(self._open_service_filter_dialog)
 
         self.filter_level_dropdown = self._log_level_box()
-        self._layout.addWidget(self.filter_level_dropdown)
-        self.filter_level_dropdown.currentTextChanged.connect(self._emit_level)
+        self.layout.addWidget(self.filter_level_dropdown)
+
+        self.clear_button = QPushButton("Clear all", self)
+        self.layout.addWidget(self.clear_button)
+        self.fetch_button = QPushButton("Fetch history", self)
+        self.layout.addWidget(self.fetch_button)
 
         self._string_search_box()
 
         self.timerange_button = QPushButton("Set time range", self)
-        self._layout.addWidget(self.timerange_button)
-        self.timerange_button.clicked.connect(self._open_datetime_dialog)
+        self.layout.addWidget(self.timerange_button)
 
-        self.pause_button = QToolButton()
-        self.pause_button.setIcon(material_icon("pause", size=(20, 20), convert_to_pixmap=False))
-        self._PLAYING_TOOLTIP = "Pause live log updates."
-        self._PAUSED_TOOLTIP = "Continue live log updates."
-        self.pause_button.setToolTip(self._PLAYING_TOOLTIP)
-        self._layout.addWidget(self.pause_button)
+    @property
+    def time_start(self):
+        return self._timestamp_start
 
-    @SafeSlot(bool)
-    def _update_pause_button_icon(self, paused):
-        if paused:
-            icon = "play_arrow"
-            tooltip = self._PAUSED_TOOLTIP
-        else:
-            icon = "pause"
-            tooltip = self._PLAYING_TOOLTIP
-        self.pause_button.setIcon(material_icon(icon, size=(20, 20), convert_to_pixmap=False))
-        self.pause_button.setToolTip(tooltip)
+    @property
+    def time_end(self):
+        return self._timestamp_end
 
     def _string_search_box(self):
-        self._layout.addWidget(QLabel("Search: "))
+        self.layout.addWidget(QLabel("Search: "))
         self.search_textbox = QLineEdit()
-        self._layout.addWidget(self.search_textbox)
-        self._layout.addWidget(QLabel("Fuzzy: "))
-        self.fuzzy = QCheckBox()
-        self._layout.addWidget(self.fuzzy)
-        self.fuzzy.checkStateChanged.connect(self._emit_fuzzy)
+        self.layout.addWidget(self.search_textbox)
+        self.layout.addWidget(QLabel("Use regex: "))
+        self.regex_enabled = QCheckBox()
+        self.layout.addWidget(self.regex_enabled)
+        self.update_re_button = QPushButton("Update search", self)
+        self.layout.addWidget(self.update_re_button)
 
     def _log_level_box(self):
         box = QComboBox()
         box.setToolTip("Display logs with equal or greater significance to the selected level.")
-        [box.addItem(level.name) for level in LogLevel]
+        [box.addItem(l.name) for l in LogLevel]
         return box
 
-    @SafeSlot(str)
-    def _emit_level(self, level: str):
-        self.level_changed.emit(LogLevel[level])
-
-    @SafeSlot(Qt.CheckState)
-    def _emit_fuzzy(self, state: Qt.CheckState):
-        self.fuzzy_changed.emit(state == Qt.CheckState.Checked)
-
     def _current_ts(self, selection_type: Literal["start", "end"]):
         if selection_type == "start":
             return self._timestamp_start
@@ -522,7 +284,6 @@ class LogPanelToolbar(QWidget):
         else:
             raise ValueError(f"timestamps can only be for the start or end, not {selection_type}")
 
-    @SafeSlot()
     def _open_datetime_dialog(self):
         """Open dialog window for timestamp filter selection"""
         self._dt_dialog = QDialog(self)
@@ -551,8 +312,8 @@ class LogPanelToolbar(QWidget):
             )
             _layout.addWidget(date_clear_button)
 
-        date_button_set("start", label_start)
-        date_button_set("end", label_end)
+        for v in [("start", label_start), ("end", label_end)]:
+            date_button_set(*v)
 
         close_button = QPushButton("Close", parent=self._dt_dialog)
         close_button.clicked.connect(self._dt_dialog.accept)
@@ -591,23 +352,27 @@ class LogPanelToolbar(QWidget):
             self._timestamp_start = dt
         else:
             self._timestamp_end = dt
-        self.timestamp_update.emit(TimestampUpdate(value=dt, update_type=selection_type))
 
-    def service_list_update(self, services_info: dict[str, StatusMessage]):
+    @SafeSlot(dict, set)
+    def service_list_update(
+        self, services_info: dict[str, StatusMessage], services_from_history: set[str], *_, **__
+    ):
         """Change the list of services which can be selected"""
         self._unique_service_names = set([s.split("/")[0] for s in services_info.keys()])
+        self._unique_service_names |= services_from_history
+        if self._services_selected is None:
+            self._services_selected = self._unique_service_names
 
     @SafeSlot()
     def _open_service_filter_dialog(self):
-        self.service_list_update(self.client.service_status)
         if len(self._unique_service_names) == 0 or self._services_selected is None:
             return
         self._svc_dialog = QDialog(self)
-        self._svc_dialog.setWindowTitle("Select services to show logs from")
+        self._svc_dialog.setWindowTitle(f"Select services to show logs from")
         layout = QVBoxLayout()
         self._svc_dialog.setLayout(layout)
 
-        service_cb_grid = QGridLayout()
+        service_cb_grid = QGridLayout(parent=self._svc_dialog)
         layout.addLayout(service_cb_grid)
 
         def check_box(name: str, checked: Qt.CheckState):
@@ -633,6 +398,146 @@ class LogPanelToolbar(QWidget):
         self._svc_dialog.deleteLater()
 
 
+class LogPanel(TextBox):
+    """Displays a log panel"""
+
+    ICON_NAME = "terminal"
+    service_list_update = Signal(dict, set)
+
+    def __init__(
+        self,
+        parent=None,
+        client: BECClient | None = None,
+        service_status: BECServiceStatusMixin | None = None,
+        **kwargs,
+    ):
+        """Initialize the LogPanel widget."""
+        super().__init__(parent=parent, client=client, config={"text": ""}, **kwargs)
+        self._update_colors()
+        self._service_status = service_status or BECServiceStatusMixin(self, client=self.client)  # type: ignore
+        self._log_manager = BecLogsQueue(
+            parent=self, line_formatter=partial(simple_color_format, colors=self._colors)
+        )
+        self._proxy_update = SignalProxy(
+            self._log_manager.new_message, rateLimit=1, slot=self._on_append
+        )
+
+        self.toolbar = LogPanelToolbar(parent=self)
+        self.toolbar_area = QScrollArea()
+        self.toolbar_area.setVerticalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
+        self.toolbar_area.setSizeAdjustPolicy(QScrollArea.SizeAdjustPolicy.AdjustToContents)
+        self.toolbar_area.setFixedHeight(int(self.toolbar.clear_button.height() * 2))
+        self.toolbar_area.setWidget(self.toolbar)
+
+        self.layout.addWidget(self.toolbar_area)
+        self.toolbar.clear_button.clicked.connect(self._on_clear)
+        self.toolbar.fetch_button.clicked.connect(self._on_fetch)
+        self.toolbar.update_re_button.clicked.connect(self._on_re_update)
+        self.toolbar.search_textbox.returnPressed.connect(self._on_re_update)
+        self.toolbar.regex_enabled.checkStateChanged.connect(self._on_re_update)
+        self.toolbar.filter_level_dropdown.currentTextChanged.connect(self._set_level_filter)
+
+        self.toolbar.timerange_button.clicked.connect(self._choose_datetime)
+        self._service_status.services_update.connect(self._update_service_list)
+        self.service_list_update.connect(self.toolbar.service_list_update)
+        self.toolbar.services_selected.connect(self._update_service_filter)
+
+        self.text_box_text_edit.setFont(QFont("monospace", 12))
+        self.text_box_text_edit.setHtml("")
+        self.text_box_text_edit.setLineWrapMode(QTextEdit.LineWrapMode.NoWrap)
+
+        self._connect_to_theme_change()
+
+    @SafeSlot(set)
+    def _update_service_filter(self, services: set[str]):
+        self._log_manager.update_service_filter(services)
+        self._on_redraw()
+
+    @SafeSlot(dict, dict)
+    def _update_service_list(self, services_info: dict[str, StatusMessage], *_, **__):
+        self.service_list_update.emit(
+            services_info, self._log_manager.unique_service_names_from_history()
+        )
+
+    @SafeSlot()
+    def _choose_datetime(self):
+        self.toolbar._open_datetime_dialog()
+        self._set_time_filter()
+
+    def _connect_to_theme_change(self):
+        """Connect to the theme change signal."""
+        qapp = QApplication.instance()
+        if hasattr(qapp, "theme_signal"):
+            qapp.theme_signal.theme_updated.connect(self._on_redraw)  # type: ignore
+
+    def _update_colors(self):
+        self._colors = DEFAULT_LOG_COLORS.copy()
+        self._colors.update({LogLevel.INFO: get_theme_palette().text().color().name()})
+
+    def _cursor_to_end(self):
+        c = self.text_box_text_edit.textCursor()
+        c.movePosition(c.MoveOperation.End)
+        self.text_box_text_edit.setTextCursor(c)
+
+    @SafeSlot()
+    @SafeSlot(str)
+    def _on_redraw(self, *_):
+        self._update_colors()
+        self._log_manager.update_line_formatter(partial(simple_color_format, colors=self._colors))
+        self.set_html_text(self._log_manager.display_all())
+        self._cursor_to_end()
+
+    @SafeSlot(verify_sender=True)
+    def _on_append(self, *_):
+        self.text_box_text_edit.insertHtml(self._log_manager.format_new())
+        self._cursor_to_end()
+
+    @SafeSlot()
+    def _on_clear(self):
+        self._log_manager.clear_logs()
+        self.set_html_text(self._log_manager.display_all())
+        self._cursor_to_end()
+
+    @SafeSlot()
+    @SafeSlot(Qt.CheckState)
+    def _on_re_update(self, *_):
+        if self.toolbar.regex_enabled.isChecked():
+            try:
+                search_query = re.compile(self.toolbar.search_textbox.text())
+            except Exception as e:
+                logger.warning(f"Failed to compile search regex with error {e}")
+                search_query = None
+            logger.info(f"Setting LogPanel search regex to {search_query}")
+        else:
+            search_query = self.toolbar.search_textbox.text()
+            logger.info(f'Setting LogPanel search string to "{search_query}"')
+        self._log_manager.update_search_filter(search_query)
+        self.set_html_text(self._log_manager.display_all())
+        self._cursor_to_end()
+
+    @SafeSlot()
+    def _on_fetch(self):
+        self._log_manager.fetch_history()
+        self.set_html_text(self._log_manager.display_all())
+        self._cursor_to_end()
+
+    @SafeSlot(str)
+    def _set_level_filter(self, level: str):
+        self._log_manager.update_level_filter(level)
+        self._on_redraw()
+
+    @SafeSlot()
+    def _set_time_filter(self):
+        self._log_manager.update_time_filter(self.toolbar.time_start, self.toolbar.time_end)
+        self._on_redraw()
+
+    def cleanup(self):
+        self._service_status.cleanup()
+        self._log_manager.cleanup()
+        self._log_manager.deleteLater()
+        super().cleanup()
+
+
 if __name__ == "__main__":  # pragma: no cover
     import sys
 
@@ -640,15 +545,7 @@ if __name__ == "__main__":  # pragma: no cover
 
     app = QApplication(sys.argv)
     apply_theme("dark")
-    panel = QWidget()
-    queue = BecLogsQueue(panel)
-    layout = QVBoxLayout(panel)
-    layout.addWidget(QLabel("All logs, no filters:"))
-    layout.addWidget(LogPanel())
-    layout.addWidget(QLabel("All services, level filter WARNING preapplied:"))
-    layout.addWidget(LogPanel(level_filter=LogLevel.WARNING))
-    layout.addWidget(QLabel('All services, service filter {"DeviceServer"} preapplied:'))
-    layout.addWidget(LogPanel(service_filter={"DeviceServer"}))
+    widget = LogPanel()
 
-    panel.show()
+    widget.show()
     sys.exit(app.exec())

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "bec_widgets"
-version = "3.6.0"
+version = "3.5.0"
 description = "BEC Widgets"
 requires-python = ">=3.11"
 classifiers = [

tests/benchmarks/hyperfine/benchmark_import_bec_widgets.sh

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+# BENCHMARK_TITLE: Import bec_widgets
+set -euo pipefail
+
+python -c 'import bec_widgets; print(bec_widgets.__file__)'

tests/benchmarks/hyperfine/benchmark_launch_bec_with_companion.sh

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+# BENCHMARK_TITLE: BEC IPython client with companion app
+set -euo pipefail
+
+bec --post-startup-file tests/benchmarks/hyperfine/utils/exit_bec_startup.py

tests/benchmarks/hyperfine/benchmark_launch_bec_without_companion.sh

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+# BENCHMARK_TITLE: BEC IPython client without companion app
+set -euo pipefail
+
+bec --nogui --post-startup-file tests/benchmarks/hyperfine/utils/exit_bec_startup.py

tests/benchmarks/hyperfine/utils/exit_bec_startup.py

@@ -0,0 +1,5 @@
+import time
+
+_ip = get_ipython()
+_ip.confirm_exit = False
+_ip.ask_exit()

tests/conftest.py

@@ -1,5 +1,3 @@
-import traceback
-
 import pytest
 import qtpy.QtCore
 from pytestqt.exceptions import TimeoutError as QtBotTimeoutError
@@ -7,14 +5,12 @@ from qtpy.QtCore import QTimer
 
 
 class TestableQTimer(QTimer):
-    _instances: list[tuple[QTimer, str, str]] = []
+    _instances: list[tuple[QTimer, str]] = []
     _current_test_name: str = ""
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
-        tb = traceback.format_stack()
-        init_line = list(filter(lambda msg: "QTimer(" in msg, tb))[-1]
-        TestableQTimer._instances.append((self, TestableQTimer._current_test_name, init_line))
+        TestableQTimer._instances.append((self, TestableQTimer._current_test_name))
 
     @classmethod
     def check_all_stopped(cls, qtbot):
@@ -24,21 +20,12 @@ class TestableQTimer(QTimer):
             except RuntimeError as e:
                 return "already deleted" in e.args[0]
 
-        def _format_timers(timers: list[tuple[QTimer, str, str]]):
-            return "\n".join(
-                f"Timer: {t[0]}\n    in test: {t[1]}\n    created at:{t[2]}" for t in timers
-            )
-
         try:
-            qtbot.waitUntil(
-                lambda: all(_is_done_or_deleted(timer) for timer, _, _ in cls._instances)
-            )
+            qtbot.waitUntil(lambda: all(_is_done_or_deleted(timer) for timer, _ in cls._instances))
         except QtBotTimeoutError as exc:
             active_timers = list(filter(lambda t: t[0].isActive(), cls._instances))
-            (t.stop() for t, _, _ in cls._instances)
-            raise TimeoutError(
-                f"Failed to stop all timers:\n{_format_timers(active_timers)}"
-            ) from exc
+            (t.stop() for t, _ in cls._instances)
+            raise TimeoutError(f"Failed to stop all timers: {active_timers}") from exc
         cls._instances = []
 
 

tests/end-2-end/conftest.py

@@ -33,7 +33,7 @@ def threads_check_fixture(threads_check):
 @pytest.fixture
 def gui_id():
     """New gui id each time, to ensure no 'gui is alive' zombie key can perturb"""
-    return f"figure_{random.randint(0, 100)}"  # make a new gui id each time, to ensure no 'gui is alive' zombie key can perturb
+    return f"figure_{random.randint(0,100)}"  # make a new gui id each time, to ensure no 'gui is alive' zombie key can perturb
 
 
 @pytest.fixture(scope="function")
@@ -51,7 +51,6 @@ def connected_client_gui_obj(qtbot, gui_id, bec_client_lib):
         qtbot.waitUntil(lambda: len(gui.bec.widget_list()) == 0, timeout=10000)
         yield gui
     finally:
-        if (bec := getattr(gui, "bec", None)) is not None:
-            bec.delete_all()  # ensure clean state
-            qtbot.waitUntil(lambda: len(bec.widget_list()) == 0, timeout=10000)
+        gui.bec.delete_all()  # ensure clean state
+        qtbot.waitUntil(lambda: len(gui.bec.widget_list()) == 0, timeout=10000)
         gui.kill_server()

tests/end-2-end/user_interaction/test_user_interaction_e2e.py

@@ -260,6 +260,22 @@ def test_widgets_e2e_image(qtbot, connected_client_gui_obj, random_generator_fro
     maybe_remove_dock_area(qtbot, gui=gui, random_int_gen=random_generator_from_seed)
 
 
+# TODO re-enable when issue is resolved #560
+# @pytest.mark.timeout(PYTEST_TIMEOUT)
+# def test_widgets_e2e_log_panel(qtbot, connected_client_gui_obj, random_generator_from_seed):
+#     """Test the LogPanel widget."""
+#     gui = connected_client_gui_obj
+#     bec = gui._client
+#     # Create dock_area and widget
+#     widget = create_widget(qtbot, gui, gui.available_widgets.LogPanel)
+#     widget: client.LogPanel
+
+#     # No rpc calls to check so far
+
+#     # Test removing the widget, or leaving it open for the next test
+#     maybe_remove_dock_area(qtbot, gui=gui, random_int_gen=random_generator_from_seed)
+
+
 @pytest.mark.timeout(PYTEST_TIMEOUT)
 def test_widgets_e2e_minesweeper(qtbot, connected_client_gui_obj, random_generator_from_seed):
     """Test the MineSweeper widget."""

tests/unit_tests/benchmarks/test_dock_area_benchmark.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+import pytest
+
+from bec_widgets.widgets.containers.dock_area.dock_area import BECDockArea
+from bec_widgets.widgets.plots.waveform.waveform import Waveform
+from tests.unit_tests.client_mocks import mocked_client
+
+
+@pytest.fixture
+def dock_area(qtbot, mocked_client):
+    widget = BECDockArea(client=mocked_client)
+    qtbot.addWidget(widget)
+    qtbot.waitExposed(widget)
+    yield widget
+
+
+def test_add_waveform_to_dock_area(benchmark, dock_area, qtbot, mocked_client):
+    """Benchmark adding a Waveform widget to an existing dock area."""
+
+    def add_waveform():
+        dock_area.new("Waveform")
+        return dock_area
+
+    dock = benchmark(add_waveform)
+
+    assert dock is not None

tests/unit_tests/test_client_plugin_widgets.py

@@ -9,8 +9,7 @@ from bec_widgets.cli.rpc.rpc_base import RPCBase
 from bec_widgets.utils.plugin_utils import BECClassContainer, BECClassInfo
 
 
-class _TestGlobalPlugin(RPCBase):
-    _IMPORT_MODULE = "test.global.plugin.widgets"
+class _TestGlobalPlugin(RPCBase): ...
 
 
 mock_client_module_globals = SimpleNamespace()
@@ -26,13 +25,12 @@ mock_client_module_globals.Widgets = _TestGlobalPlugin
 def test_plugins_dont_clobber_client_globals(bec_logger: MagicMock):
     reload(client)
     bec_logger.logger.warning.assert_called_with(
-        "Plugin widget Widgets in test.global.plugin.widgets conflicts with a built-in class!"
+        "Plugin widget Widgets from namespace(Widgets=<class 'tests.unit_tests.test_client_plugin_widgets._TestGlobalPlugin'>) conflicts with a built-in class!"
     )
     assert isinstance(client.Widgets, enum.EnumType)
 
 
-class _TestDuplicatePlugin(RPCBase):
-    _IMPORT_MODULE = "test.duplicate.plugin.module"
+class _TestDuplicatePlugin(RPCBase): ...
 
 
 mock_client_module_duplicate = SimpleNamespace()
@@ -56,7 +54,7 @@ def test_duplicate_plugins_not_allowed(_, bec_logger: MagicMock):
     reload(client)
     assert (
         call(
-            "Plugin widget Waveform in test.duplicate.plugin.module conflicts with a built-in class!"
+            f"Detected duplicate widget Waveform in plugin repo file: {inspect.getfile(_TestDuplicatePlugin)} !"
         )
         in bec_logger.logger.warning.mock_calls
     )

tests/unit_tests/test_dock_area.py

@@ -2229,6 +2229,7 @@ class TestFlatToolbarActions:
             "flat_progress_bar",
             "flat_terminal",
             "flat_bec_shell",
+            "flat_log_panel",
             "flat_sbb_monitor",
         ]
 
@@ -2288,6 +2289,11 @@ class TestFlatToolbarActions:
                 action.trigger()
                 mock_new.assert_called_once_with(widget_type)
 
+    def test_flat_log_panel_action_disabled(self, advanced_dock_area):
+        """Test that flat log panel action is disabled."""
+        action = advanced_dock_area.toolbar.components.get_action("flat_log_panel").action
+        assert not action.isEnabled()
+
 
 class TestModeTransitions:
     """Test mode transitions and state consistency."""

tests/unit_tests/test_generate_cli_client.py

@@ -104,7 +104,8 @@ def test_client_generator_with_black_formatting():
         from bec_lib.logger import bec_logger
 
         from bec_widgets.cli.rpc.rpc_base import RPCBase, rpc_call, rpc_timeout
-        from bec_widgets.utils.bec_plugin_helper import get_plugin_client_module
+        from bec_widgets.utils.bec_plugin_helper import (get_all_plugin_widgets,
+                                                        get_plugin_client_module)
 
         logger = bec_logger.logger
 
@@ -122,25 +123,31 @@ def test_client_generator_with_black_formatting():
 
         
         try:
+            _plugin_widgets = get_all_plugin_widgets().as_dict()
             plugin_client = get_plugin_client_module()
+            Widgets = _WidgetsEnumType("Widgets", {name: name for name in _plugin_widgets} | _Widgets)
+
+            if (_overlap := _Widgets.keys() & _plugin_widgets.keys()) != set():
+                for _widget in _overlap:
+                    logger.warning(f"Detected duplicate widget {_widget} in plugin repo file: {inspect.getfile(_plugin_widgets[_widget])} !")
             for plugin_name, plugin_class in inspect.getmembers(plugin_client, inspect.isclass):
                 if issubclass(plugin_class, RPCBase) and plugin_class is not RPCBase:
-                    if plugin_name not in _Widgets:
-                        _Widgets[plugin_name] = plugin_name
                     if plugin_name in globals():
+                        conflicting_file = (
+                            inspect.getfile(_plugin_widgets[plugin_name])
+                            if plugin_name in _plugin_widgets
+                            else f"{plugin_client}"
+                        )
                         logger.warning(
-                            f"Plugin widget {plugin_name} in {plugin_class._IMPORT_MODULE} conflicts with a built-in class!"
+                            f"Plugin widget {plugin_name} from {conflicting_file} conflicts with a built-in class!"
                         )
                         continue
-                    else:
+                    if plugin_name not in _overlap:
                         globals()[plugin_name] = plugin_class
-                Widgets = _WidgetsEnumType("Widgets", _Widgets)
         except ImportError as e:
             logger.error(f"Failed loading plugins: \\n{reduce(add, traceback.format_exception(e))}")
 
         class MockBECFigure(RPCBase):
-            _IMPORT_MODULE = "tests.unit_tests.test_generate_cli_client"
-            
             @rpc_call
             def add_plot(self, plot_id: str):
                 """
@@ -155,8 +162,6 @@ def test_client_generator_with_black_formatting():
 
 
         class MockBECWaveform1D(RPCBase):
-            _IMPORT_MODULE = "tests.unit_tests.test_generate_cli_client"
-            
             @rpc_call
             def set_frequency(self, frequency: float) -> list:
                 """

tests/unit_tests/test_logpanel.py

@@ -7,123 +7,163 @@ from collections import deque
 from unittest.mock import MagicMock, patch
 
 import pytest
-from bec_lib.logger import LogLevel
 from bec_lib.messages import LogMessage
+from bec_lib.redis_connector import StreamMessage
 from qtpy.QtCore import QDateTime
 
-from bec_widgets.widgets.utility.logpanel.logpanel import LogPanel, TimestampUpdate
+from bec_widgets.widgets.utility.logpanel._util import (
+    log_time,
+    replace_escapes,
+    simple_color_format,
+)
+from bec_widgets.widgets.utility.logpanel.logpanel import DEFAULT_LOG_COLORS, LogPanel
 
 from .client_mocks import mocked_client
 
+TEST_TABLE_STRING = "2025-01-15 15:57:18 | bec_server.scan_server.scan_queue | [INFO] | \n \x1b[3m              primary queue / ScanQueueStatus.RUNNING              \x1b[0m\n┏━━━━━━━━━━━━━┳━━━━━━━━━┳━━━━━━━━━┳━━━━━━┳━━━━━━━━━━━━┳━━━━━━━━━━━┓\n┃\x1b[1m \x1b[0m\x1b[1m queue_id  \x1b[0m\x1b[1m \x1b[0m┃\x1b[1m \x1b[0m\x1b[1mscan_id\x1b[0m\x1b[1m \x1b[0m┃\x1b[1m \x1b[0m\x1b[1mis_scan\x1b[0m\x1b[1m \x1b[0m┃\x1b[1m \x1b[0m\x1b[1mtype\x1b[0m\x1b[1m \x1b[0m┃\x1b[1m \x1b[0m\x1b[1mscan_numb…\x1b[0m\x1b[1m \x1b[0m┃\x1b[1m \x1b[0m\x1b[1mIQ status\x1b[0m\x1b[1m \x1b[0m┃\n┡━━━━━━━━━━━━━╇━━━━━━━━━╇━━━━━━━━━╇━━━━━━╇━━━━━━━━━━━━╇━━━━━━━━━━━┩\n│ bbe50c82-6… │  None   │  False  │  mv  │    None    │  PENDING  │\n└─────────────┴─────────┴─────────┴──────┴────────────┴───────────┘\n\n"
+
 TEST_LOG_MESSAGES = [
-    {"data": msg}
-    for msg in [
-        LogMessage(
+    LogMessage(
+        metadata={},
+        log_type="debug",
+        log_msg={
+            "text": "datetime | debug | test log message",
+            "record": {"time": {"timestamp": 123456789.000}},
+            "service_name": "ScanServer",
+        },
+    ),
+    LogMessage(
+        metadata={},
+        log_type="info",
+        log_msg={
+            "text": "datetime | info | test log message",
+            "record": {"time": {"timestamp": 123456789.007}},
+            "service_name": "ScanServer",
+        },
+    ),
+    LogMessage(
+        metadata={},
+        log_type="success",
+        log_msg={
+            "text": "datetime | success | test log message",
+            "record": {"time": {"timestamp": 123456789.012}},
+            "service_name": "ScanServer",
+        },
+    ),
+]
+
+TEST_COMBINED_PLAINTEXT = "datetime | debug | test log message\ndatetime | info | test log message\ndatetime | success | test log message\n"
+
+
+@pytest.fixture
+def raw_queue():
+    yield deque(TEST_LOG_MESSAGES, maxlen=100)
+
+
+@pytest.fixture
+def log_panel(qtbot, mocked_client: MagicMock):
+    widget = LogPanel(client=mocked_client, service_status=MagicMock())
+    qtbot.addWidget(widget)
+    qtbot.waitExposed(widget)
+    yield widget
+
+
+def test_log_panel_init(log_panel: LogPanel):
+    assert log_panel.plain_text == ""
+
+
+def test_table_string_processing():
+    assert "\x1b" in TEST_TABLE_STRING
+    sanitized = replace_escapes(TEST_TABLE_STRING)
+    assert "\x1b" not in sanitized
+    assert "  " not in sanitized
+    assert "\n" not in sanitized
+
+
+@pytest.mark.parametrize(
+    ["msg", "color"], zip(TEST_LOG_MESSAGES, ["#0000CC", "#FFFFFF", "#00FF00"])
+)
+def test_color_format(msg: LogMessage, color: str):
+    assert color in simple_color_format(msg, DEFAULT_LOG_COLORS)
+
+
+def test_logpanel_output(qtbot, log_panel: LogPanel):
+    log_panel._log_manager._data = deque(TEST_LOG_MESSAGES)
+    log_panel._on_redraw()
+    assert log_panel.plain_text == TEST_COMBINED_PLAINTEXT
+
+    def display_queue_empty():
+        print(log_panel._log_manager._display_queue)
+        return len(log_panel._log_manager._display_queue) == 0
+
+    next_text = "datetime | error | test log message"
+    msg = LogMessage(
+        metadata={},
+        log_type="error",
+        log_msg={"text": next_text, "record": {}, "service_name": "ScanServer"},
+    )
+    log_panel._log_manager._process_incoming_log_msg(
+        msg.content, msg.metadata, _override_slot_params={"verify_sender": False}
+    )
+
+    qtbot.waitUntil(display_queue_empty, timeout=5000)
+    assert log_panel.plain_text == TEST_COMBINED_PLAINTEXT + next_text + "\n"
+
+
+def test_level_filter(log_panel: LogPanel):
+    log_panel._log_manager._data = deque(TEST_LOG_MESSAGES)
+    log_panel._log_manager.update_level_filter("INFO")
+    log_panel._on_redraw()
+    assert (
+        log_panel.plain_text
+        == "datetime | info | test log message\ndatetime | success | test log message\n"
+    )
+
+
+def test_clear_button(log_panel: LogPanel):
+    log_panel._log_manager._data = deque(TEST_LOG_MESSAGES)
+    log_panel.toolbar.clear_button.click()
+    assert log_panel._log_manager._data == deque([])
+
+
+def test_timestamp_filter(log_panel: LogPanel):
+    log_panel._log_manager._timestamp_start = QDateTime(1973, 11, 29, 21, 33, 9, 5, 1)
+    pytest.approx(log_panel._log_manager._timestamp_start.toMSecsSinceEpoch() / 1000, 123456789.005)
+    log_panel._log_manager._timestamp_end = QDateTime(1973, 11, 29, 21, 33, 9, 10, 1)
+    pytest.approx(log_panel._log_manager._timestamp_end.toMSecsSinceEpoch() / 1000, 123456789.010)
+    filter_ = log_panel._log_manager._create_timestamp_filter()
+    assert not filter_(TEST_LOG_MESSAGES[0])
+    assert filter_(TEST_LOG_MESSAGES[1])
+    assert not filter_(TEST_LOG_MESSAGES[2])
+
+
+def test_error_handling_in_callback(log_panel: LogPanel):
+    log_panel._log_manager.new_message = MagicMock()
+
+    with patch("bec_widgets.widgets.utility.logpanel.logpanel.logger") as logger:
+        # generally errors should be logged
+        log_panel._log_manager.new_message.emit = MagicMock(
+            side_effect=ValueError("Something went wrong")
+        )
+        msg = LogMessage(
             metadata={},
             log_type="debug",
             log_msg={
                 "text": "datetime | debug | test log message",
-                "record": {
-                    "time": {"timestamp": 123456789.000, "repr": "2025-01-01 00:00:01"},
-                    "message": "test debug message abcd",
-                    "function": "_debug",
-                },
-                "service_name": "ScanServer",
-            },
-        ),
-        LogMessage(
-            metadata={},
-            log_type="info",
-            log_msg={
-                "text": "datetime | info | test info log message",
-                "record": {
-                    "time": {"timestamp": 123456789.007, "repr": "2025-01-01 00:00:02"},
-                    "message": "test info message efgh",
-                    "function": "_info",
-                },
-                "service_name": "DeviceServer",
-            },
-        ),
-        LogMessage(
-            metadata={},
-            log_type="success",
-            log_msg={
-                "text": "datetime | success | test log message",
-                "record": {
-                    "time": {"timestamp": 123456789.012, "repr": "2025-01-01 00:00:03"},
-                    "message": "test success message ijkl",
-                    "function": "_success",
-                },
-                "service_name": "ScanServer",
-            },
-        ),
-    ]
-]
-
-
-@pytest.fixture
-def log_panel(qtbot, mocked_client):
-    mocked_client.connector.xread = lambda *_, **__: TEST_LOG_MESSAGES
-    widget = LogPanel()
-    qtbot.addWidget(widget)
-    qtbot.waitExposed(widget)
-    yield widget
-    widget._model.log_queue.cleanup()
-    widget.close()
-    widget.deleteLater()
-    qtbot.wait(100)
-
-
-def test_log_panel_init(qtbot, log_panel: LogPanel):
-    assert log_panel
-
-
-def test_log_panel_filters(qtbot, log_panel: LogPanel):
-    assert log_panel._proxy.rowCount() == 3
-    # Service filter
-    log_panel._update_service_filter({"DeviceServer"})
-    qtbot.waitUntil(lambda: log_panel._proxy.rowCount() == 1, timeout=200)
-    log_panel._update_service_filter(set())
-    qtbot.waitUntil(lambda: log_panel._proxy.rowCount() == 3, timeout=200)
-    # Text filter
-    log_panel._proxy.update_filter_text("efgh")
-    qtbot.waitUntil(lambda: log_panel._proxy.rowCount() == 1, timeout=200)
-    log_panel._proxy.update_filter_text("")
-    qtbot.waitUntil(lambda: log_panel._proxy.rowCount() == 3, timeout=200)
-    # Time filter
-    log_panel._proxy.update_timestamp(
-        TimestampUpdate(value=QDateTime.fromMSecsSinceEpoch(123456789004), update_type="start")
-    )
-    qtbot.waitUntil(lambda: log_panel._proxy.rowCount() == 2, timeout=200)
-    log_panel._proxy.update_timestamp(
-        TimestampUpdate(value=QDateTime.fromMSecsSinceEpoch(123456789009), update_type="end")
-    )
-    qtbot.waitUntil(lambda: log_panel._proxy.rowCount() == 1, timeout=200)
-    log_panel._proxy.update_timestamp(TimestampUpdate(value=None, update_type="start"))
-    log_panel._proxy.update_timestamp(TimestampUpdate(value=None, update_type="end"))
-    qtbot.waitUntil(lambda: log_panel._proxy.rowCount() == 3, timeout=200)
-    # Level filter
-    log_panel._proxy.update_level_filter(LogLevel.SUCCESS)
-    qtbot.waitUntil(lambda: log_panel._proxy.rowCount() == 1, timeout=200)
-    log_panel._proxy.update_level_filter(None)
-    qtbot.waitUntil(lambda: log_panel._proxy.rowCount() == 3, timeout=200)
-
-
-def test_log_panel_update(qtbot, log_panel: LogPanel):
-    log_panel._model.log_queue._incoming.append(
-        LogMessage(
-            metadata={},
-            log_type="error",
-            log_msg={
-                "text": "datetime | error | test log message",
-                "record": {
-                    "time": {"timestamp": 123456789.015, "repr": "2025-01-01 00:00:03"},
-                    "message": "test error message xyz",
-                    "function": "_error",
-                },
+                "record": {"time": {"timestamp": 123456789.000}},
                 "service_name": "ScanServer",
             },
         )
-    )
-    log_panel._model.log_queue._proc_update()
-    qtbot.waitUntil(lambda: log_panel._model.rowCount() == 4, timeout=500)
+        log_panel._log_manager._process_incoming_log_msg(
+            msg.content, msg.metadata, _override_slot_params={"verify_sender": False}
+        )
+        logger.warning.assert_called_once()
+
+        # this specific error should be ignored and not relogged
+        log_panel._log_manager.new_message.emit = MagicMock(
+            side_effect=RuntimeError("Internal C++ object (BecLogsQueue) already deleted.")
+        )
+        log_panel._log_manager._process_incoming_log_msg(
+            msg.content, msg.metadata, _override_slot_params={"verify_sender": False}
+        )
+        logger.warning.assert_called_once()