nautobot 2.3.15b1__py3-none-any.whl → 2.4.0__py3-none-any.whl

nautobot/extras/jobs.py

@@ -18,6 +18,7 @@ from db_file_storage.form_widgets import DBClearableFileInput
 from django import forms
 from django.conf import settings
 from django.contrib.auth import get_user_model
+from django.core.cache import cache
 from django.core.exceptions import ObjectDoesNotExist
 from django.core.files.base import ContentFile
 from django.core.files.uploadedfile import UploadedFile
@@ -30,25 +31,32 @@ import netaddr
 import yaml
 
 from nautobot.core.celery import import_jobs, nautobot_task
+from nautobot.core.events import publish_event
 from nautobot.core.forms import (
     DynamicModelChoiceField,
     DynamicModelMultipleChoiceField,
     JSONField,
 )
 from nautobot.core.utils.config import get_settings_or_config
+from nautobot.core.utils.logging import sanitize
 from nautobot.core.utils.lookup import get_model_from_name
-from nautobot.extras.choices import JobResultStatusChoices, ObjectChangeActionChoices, ObjectChangeEventContextChoices
+from nautobot.extras.choices import (
+    JobResultStatusChoices,
+    ObjectChangeActionChoices,
+    ObjectChangeEventContextChoices,
+)
 from nautobot.extras.context_managers import web_request_context
 from nautobot.extras.forms import JobForm
 from nautobot.extras.models import (
     FileProxy,
     Job as JobModel,
     JobHook,
+    JobQueue,
     JobResult,
     ObjectChange,
 )
 from nautobot.extras.registry import registry
-from nautobot.extras.utils import change_logged_models_queryset, task_queues_as_choices
+from nautobot.extras.utils import change_logged_models_queryset
 from nautobot.ipam.formfields import IPAddressFormField, IPNetworkFormField
 from nautobot.ipam.validators import (
     MaxPrefixLengthValidator,
@@ -60,15 +68,15 @@ User = get_user_model()
 
 
 __all__ = [
-    "Job",
     "BooleanVar",
     "ChoiceVar",
     "FileVar",
-    "IntegerVar",
     "IPAddressVar",
     "IPAddressWithMaskVar",
     "IPNetworkVar",
+    "IntegerVar",
     "JSONVar",
+    "Job",
     "MultiChoiceVar",
     "MultiObjectVar",
     "ObjectVar",
@@ -107,6 +115,7 @@ class BaseJob:
         - task_queues (list)
         - template_name (str)
         - time_limit (int)
+        - is_singleton (bool)
         """
 
     def __init__(self):
@@ -184,6 +193,31 @@ class BaseJob:
             )
             raise RunJobTaskFailed(f"Job {self.job_model} is not enabled to be run!")
 
+        ignore_singleton_lock = self.celery_kwargs.get("nautobot_job_ignore_singleton_lock", False)
+        if self.job_model.is_singleton:
+            is_running = cache.get(self.singleton_cache_key)
+            if is_running:
+                if ignore_singleton_lock:
+                    self.logger.info(
+                        "Job %s is a singleton and already running, but singleton will be ignored because"
+                        " `ignore_singleton_lock` is set.",
+                        self.job_model,
+                        extra={"object": self.job_model, "grouping": "initialization"},
+                    )
+                else:
+                    self.logger.error(
+                        "Job %s is a singleton and already running.",
+                        self.job_model,
+                        extra={"object": self.job_model, "grouping": "initialization"},
+                    )
+                    raise RunJobTaskFailed(f"Job '{self.job_model}' is a singleton and already running.")
+            cache_parameters = {
+                "key": self.singleton_cache_key,
+                "value": 1,
+                "timeout": self.job_model.time_limit or settings.CELERY_TASK_TIME_LIMIT,
+            }
+            cache.set(**cache_parameters)
+
         soft_time_limit = self.job_model.soft_time_limit or settings.CELERY_TASK_SOFT_TIME_LIMIT
         time_limit = self.job_model.time_limit or settings.CELERY_TASK_TIME_LIMIT
         if time_limit <= soft_time_limit:
@@ -275,7 +309,15 @@ class BaseJob:
             self._delete_file_proxies(*file_ids)
 
         if status == JobResultStatusChoices.STATUS_SUCCESS:
-            self.logger.info("Job completed", extra={"grouping": "post_run"})
+            self.logger.success("Job completed", extra={"grouping": "post_run"})
+
+        cache.delete(self.singleton_cache_key)
+
+    @final
+    @classproperty
+    def singleton_cache_key(cls) -> str:  # pylint: disable=no-self-argument
+        """Cache key for singleton jobs."""
+        return f"nautobot.extras.jobs.running.{cls.class_path}"
 
     @final
     @classproperty
@@ -295,7 +337,7 @@ class BaseJob:
         - my_plugin.jobs.MyPluginJob - App-provided Job
         - git_repository.jobs.myjob.MyJob - GitRepository Job
         """
-        return f"{cls.__module__}.{cls.__name__}"
+        return f"{cls.__module__}.{cls.__name__}"  # pylint: disable=no-member
 
     @final
     @classproperty
@@ -332,7 +374,7 @@ class BaseJob:
     @final
     @classproperty
     def name(cls) -> str:  # pylint: disable=no-self-argument
-        return cls._get_meta_attr_and_assert_type("name", cls.__name__, expected_type=str)
+        return cls._get_meta_attr_and_assert_type("name", cls.__name__, expected_type=str)  # pylint: disable=no-member
 
     @final
     @classproperty
@@ -396,6 +438,11 @@ class BaseJob:
     def task_queues(cls) -> list:  # pylint: disable=no-self-argument
         return cls._get_meta_attr_and_assert_type("task_queues", [], expected_type=(list, tuple))
 
+    @final
+    @classproperty
+    def is_singleton(cls) -> bool:  # pylint: disable=no-self-argument
+        return cls._get_meta_attr_and_assert_type("is_singleton", False, expected_type=bool)
+
     @final
     @classproperty
     def properties_dict(cls) -> dict:  # pylint: disable=no-self-argument
@@ -414,13 +461,14 @@ class BaseJob:
             "time_limit": cls.time_limit,
             "has_sensitive_variables": cls.has_sensitive_variables,
             "task_queues": cls.task_queues,
+            "is_singleton": cls.is_singleton,
         }
 
     @final
     @classproperty
     def registered_name(cls) -> str:  # pylint: disable=no-self-argument
         """Deprecated - use class_path classproperty instead."""
-        return f"{cls.__module__}.{cls.__name__}"
+        return f"{cls.__module__}.{cls.__name__}"  # pylint: disable=no-member
 
     @classmethod
     def _get_vars(cls):
@@ -475,18 +523,41 @@ class BaseJob:
         """
 
         form = cls.as_form_class()(data, files, initial=initial)
-
+        form.fields["_profile"] = forms.BooleanField(
+            required=False,
+            initial=False,
+            label="Profile job execution",
+            help_text="Profiles the job execution using cProfile and outputs a report to /tmp/",
+        )
+        # If the class already exists there may be overrides, so we have to check this.
         try:
-            job_model = JobModel.objects.get_for_class_path(cls.class_path)
-            dryrun_default = job_model.dryrun_default if job_model.dryrun_default_override else cls.dryrun_default
-            task_queues = job_model.task_queues if job_model.task_queues_override else cls.task_queues
+            job_model = JobModel.objects.get(module_name=cls.__module__, job_class_name=cls.__name__)
+            is_singleton = job_model.is_singleton
         except JobModel.DoesNotExist:
-            logger.error("No Job instance found in the database corresponding to %s", cls.class_path)
-            dryrun_default = cls.dryrun_default
-            task_queues = cls.task_queues
+            is_singleton = cls.is_singleton
+        if is_singleton:
+            form.fields["_ignore_singleton_lock"] = forms.BooleanField(
+                required=False,
+                initial=False,
+                label="Ignore singleton lock",
+                help_text="Allow this singleton job to run even when another instance is already running",
+            )
 
-        # Update task queue choices
-        form.fields["_task_queue"].choices = task_queues_as_choices(task_queues)
+        job_model = JobModel.objects.get_for_class_path(cls.class_path)
+        dryrun_default = job_model.dryrun_default if job_model.dryrun_default_override else cls.dryrun_default
+        job_queue_queryset = JobQueue.objects.filter(jobs=job_model)
+        job_queue_params = {"jobs": [job_model.pk]}
+
+        # Initialize job_queue choices
+        form.fields["_job_queue"] = DynamicModelChoiceField(
+            queryset=job_queue_queryset,
+            query_params=job_queue_params,
+            required=False,
+            help_text="The job queue to route this job to",
+            label="Job queue",
+        )
+        # Populate the job queue field on the JobRun Form
+        form.fields["_job_queue"].initial = job_model.default_job_queue.pk
 
         if cls.supports_dryrun and (not initial or "dryrun" not in initial):
             # Set initial "dryrun" checkbox state based on the Meta parameter
@@ -503,6 +574,13 @@ class BaseJob:
             for _, field in form.fields.items():
                 field.disabled = True
 
+        # Ensure non-Job-specific fields are still last after applying field_order
+        for field in ["_job_queue", "_profile", "_ignore_singleton_lock"]:
+            if field not in form.fields:
+                continue
+            value = form.fields.pop(field)
+            form.fields[field] = value
+
         return form
 
     @functools.cached_property
@@ -721,7 +799,7 @@ class BaseJob:
         """
         if isinstance(content, str):
             content = content.encode("utf-8")
-        max_size = get_settings_or_config("JOB_CREATE_FILE_MAX_SIZE")
+        max_size = get_settings_or_config("JOB_CREATE_FILE_MAX_SIZE", fallback=10 << 20)
         actual_size = len(content)
         if actual_size > max_size:
             raise ValueError(f"Provided {actual_size} bytes of content, but JOB_CREATE_FILE_MAX_SIZE is {max_size}")
@@ -1011,7 +1089,7 @@ class JobHookReceiver(Job):
 
     object_change = ObjectVar(model=ObjectChange)
 
-    def run(self, object_change):
+    def run(self, object_change):  # pylint: disable=arguments-differ
         """JobHookReceiver subclasses generally shouldn't need to override this method."""
         self.receive_job_hook(
             change=object_change,
@@ -1040,7 +1118,7 @@ class JobButtonReceiver(Job):
     object_pk = StringVar()
     object_model_name = StringVar()
 
-    def run(self, object_pk, object_model_name):
+    def run(self, object_pk, object_model_name):  # pylint: disable=arguments-differ
         """JobButtonReceiver subclasses generally shouldn't need to override this method."""
         model = get_model_from_name(object_model_name)
         obj = model.objects.get(pk=object_pk)
@@ -1133,16 +1211,32 @@ def run_job(self, job_class_path, *args, **kwargs):
         raise KeyError(f"Job class not found for class path {job_class_path}")
     job = job_class()
     job.request = self.request
+    job_result = JobResult.objects.get(id=self.request.id)
+    payload = {
+        "job_result_id": self.request.id,
+        "job_name": job.name,
+        "user_name": job_result.user.username,
+    }
+    if not job.job_model.has_sensitive_variables:
+        payload["job_kwargs"] = kwargs
     try:
+        publish_event(topic="nautobot.jobs.job.started", payload=payload)
         job.before_start(self.request.id, args, kwargs)
         result = job(*args, **kwargs)
         job.on_success(result, self.request.id, args, kwargs)
         job.after_return(JobResultStatusChoices.STATUS_SUCCESS, result, self.request.id, args, kwargs, None)
+        payload["job_output"] = result
+        publish_event(topic="nautobot.jobs.job.completed", payload=payload)
         return result
     except Exception as exc:
         einfo = ExceptionInfo(sys.exc_info())
         job.on_failure(exc, self.request.id, args, kwargs, einfo)
         job.after_return(JobResultStatusChoices.STATUS_FAILURE, exc, self.request.id, args, kwargs, einfo)
+        payload["einfo"] = {
+            "exc_type": type(exc).__name__,
+            "exc_message": sanitize(str(exc)),
+        }
+        publish_event(topic="nautobot.jobs.job.completed", payload=payload)
         raise
 
 

nautobot/extras/management/__init__.py

@@ -28,6 +28,7 @@ STATUS_CHOICESET_MAP = {
     "dcim.InterfaceRedundancyGroup": dcim_choices.InterfaceRedundancyGroupStatusChoices,
     "dcim.SoftwareImageFile": dcim_choices.SoftwareImageFileStatusChoices,
     "dcim.SoftwareVersion": dcim_choices.SoftwareVersionStatusChoices,
+    "dcim.VirtualDeviceContext": dcim_choices.VirtualDeviceContextStatusChoices,
     "extras.ContactAssociation": extras_choices.ContactAssociationStatusChoices,
     "ipam.IPAddress": ipam_choices.IPAddressStatusChoices,
     "ipam.Prefix": ipam_choices.PrefixStatusChoices,

nautobot/extras/management/commands/runjob.py

@@ -1,14 +1,11 @@
-import json
 import time
 
 from django.contrib.auth import get_user_model
 from django.core.management.base import BaseCommand, CommandError
-from django.utils import timezone
 
-from nautobot.extras.choices import JobResultStatusChoices, LogLevelChoices
-from nautobot.extras.jobs import get_job
-from nautobot.extras.models import Job, JobLogEntry, JobResult
-from nautobot.extras.utils import get_worker_count
+from nautobot.extras.choices import JobResultStatusChoices
+from nautobot.extras.management.utils import report_job_status, validate_job_and_job_data
+from nautobot.extras.models import Job, JobResult
 
 
 class Command(BaseCommand):
@@ -38,42 +35,15 @@ class Command(BaseCommand):
     def handle(self, *args, **options):
         if "." not in options["job"]:
             raise CommandError('Job must be specified in the Python module form: "<module_name>.<JobClassName>"')
-        job_class = get_job(options["job"])
-        if not job_class:
-            raise CommandError(f'Job "{options["job"]}" not found')
-
         User = get_user_model()
         try:
             user = User.objects.get(username=options["username"])
         except User.DoesNotExist as exc:
             raise CommandError("No such user") from exc
 
-        data = {}
-        try:
-            if options.get("data"):
-                data = json.loads(options["data"])
-        except json.decoder.JSONDecodeError as error:
-            raise CommandError(f"Invalid JSON data:\n{error!s}") from error
-
-        try:
-            job_model = Job.objects.get_for_class_path(options["job"])
-        except Job.DoesNotExist as error:
-            raise CommandError(f"Job {options['job']} does not exist.") from error
-
-        try:
-            job_model = Job.objects.restrict(user, "run").get_for_class_path(options["job"])
-        except Job.DoesNotExist:
-            raise CommandError(f"User {options['username']} does not have permission to run this Job") from None
-
-        if not job_model.installed or job_model.job_class is None:
-            raise CommandError("Job is not presently installed")
-        if not job_model.enabled:
-            raise CommandError("Job is not presently enabled to be run")
-        if not options["local"] and not get_worker_count():
-            raise CommandError("No Celery worker detected. Perhaps you meant to specify --local?")
-
-        # Run the job and create a new JobResult
-        self.stdout.write(f"[{timezone.now():%H:%M:%S}] Running {options['job']}...")
+        job_class_path = options["job"]
+        data = validate_job_and_job_data(self, user, job_class_path, options.get("data"))
+        job_model = Job.objects.get_for_class_path(job_class_path)
 
         if options["local"]:
             job_result = JobResult.execute_job(job_model, user, profile=options["profile"], **data)
@@ -86,46 +56,4 @@ class Command(BaseCommand):
                 job_result.refresh_from_db()
 
         # Report on success/failure
-        groups = set(JobLogEntry.objects.filter(job_result=job_result).values_list("grouping", flat=True))
-        for group in sorted(groups):
-            logs = JobLogEntry.objects.filter(job_result__pk=job_result.pk, grouping=group)
-            debug_count = logs.filter(log_level=LogLevelChoices.LOG_DEBUG).count()
-            info_count = logs.filter(log_level=LogLevelChoices.LOG_INFO).count()
-            warning_count = logs.filter(log_level=LogLevelChoices.LOG_WARNING).count()
-            error_count = logs.filter(log_level=LogLevelChoices.LOG_ERROR).count()
-            critical_count = logs.filter(log_level=LogLevelChoices.LOG_CRITICAL).count()
-
-            self.stdout.write(
-                f"\t{group}: {debug_count} debug, {info_count} info, {warning_count} warning, {error_count} error, {critical_count} critical"
-            )
-
-            for log_entry in logs:
-                status = log_entry.log_level
-                if status == "success":
-                    status = self.style.SUCCESS(status)
-                elif status == "info":
-                    status = status
-                elif status == "warning":
-                    status = self.style.WARNING(status)
-                elif status == "failure":
-                    status = self.style.NOTICE(status)
-
-                if log_entry.log_object:
-                    self.stdout.write(f"\t\t{status}: {log_entry.log_object}: {log_entry.message}")
-                else:
-                    self.stdout.write(f"\t\t{status}: {log_entry.message}")
-
-        if job_result.result:
-            self.stdout.write(str(job_result.result))
-
-        if job_result.status == JobResultStatusChoices.STATUS_FAILURE:
-            status = self.style.ERROR("FAILURE")
-        elif job_result.status == JobResultStatusChoices.STATUS_SUCCESS:
-            status = self.style.SUCCESS("SUCCESS")
-        else:
-            status = self.style.WARNING(job_result.status)
-        self.stdout.write(f"[{timezone.now():%H:%M:%S}] {options['job']}: {status}")
-
-        # Wrap things up
-        self.stdout.write(f"[{timezone.now():%H:%M:%S}] {options['job']}: Duration {job_result.duration}")
-        self.stdout.write(f"[{timezone.now():%H:%M:%S}] Finished")
+        report_job_status(self, job_result)

nautobot/extras/management/commands/runjob_with_job_result.py

@@ -0,0 +1,46 @@
+from django.core.management.base import BaseCommand, CommandError
+
+from nautobot.extras.choices import JobResultStatusChoices
+from nautobot.extras.management.utils import report_job_status, validate_job_and_job_data
+from nautobot.extras.models import JobResult
+
+
+class Command(BaseCommand):
+    help = "Run a job (script, report) to validate or update data in Nautobot"
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            "job_result",
+            help="Pass in an existing job result id from the database to continue executing the job on a local system",
+        )
+        parser.add_argument(
+            "--profile",
+            action="store_true",
+            help="Run cProfile on the job execution and write the result to the disk under /tmp.",
+        )
+
+    def handle(self, *args, **options):
+        job_result = None
+        job_result_id = options["job_result"]
+        try:
+            job_result = JobResult.objects.get(pk=job_result_id)
+        except JobResult.DoesNotExist:
+            raise CommandError(f"Job result with pk {job_result_id} not found.")
+        if job_result.status != JobResultStatusChoices.STATUS_PENDING:
+            raise CommandError(
+                f"Job result has an invalid status {job_result.status} for this command."
+                f" You can only pass in a job result with status {JobResultStatusChoices.STATUS_PENDING}"
+            )
+
+        job_user = job_result.user
+        job_model = job_result.job_model
+        job_class_path = job_model.class_path
+
+        data = validate_job_and_job_data(self, job_user, job_class_path, job_result.task_kwargs)
+
+        # execute_job here implies "--local"
+        job_result = JobResult.execute_job(
+            job_model, job_user, profile=options["profile"], job_result=job_result, **data
+        )
+        # Report on success/failure
+        report_job_status(self, job_result)

nautobot/extras/management/utils.py

@@ -0,0 +1,87 @@
+import json
+
+from django.core.management.base import CommandError
+from django.utils import timezone
+
+from nautobot.extras.choices import JobResultStatusChoices, LogLevelChoices
+from nautobot.extras.jobs import get_job
+from nautobot.extras.models import Job, JobLogEntry
+
+
+def validate_job_and_job_data(command, user, job_class_path, data=None):
+    job_data = {}
+    try:
+        if data:
+            job_data = json.loads(data)
+    except json.decoder.JSONDecodeError as error:
+        raise CommandError(f"Invalid JSON data:\n{error!s}") from error
+
+    if not get_job(job_class_path, reload=True):
+        raise CommandError(f'Job "{job_class_path}" not found')
+
+    try:
+        job_model = Job.objects.get_for_class_path(job_class_path)
+    except Job.DoesNotExist as error:
+        raise CommandError(f"Job {job_class_path} does not exist.") from error
+
+    try:
+        job_model = Job.objects.restrict(user, "run").get_for_class_path(job_class_path)
+    except Job.DoesNotExist:
+        raise CommandError(f"User {user.username} does not have permission to run this Job") from None
+
+    if not job_model.installed or job_model.job_class is None:
+        raise CommandError("Job is not presently installed")
+    if not job_model.enabled:
+        raise CommandError("Job is not presently enabled to be run")
+
+    # Run the job and create a new JobResult
+    command.stdout.write(f"[{timezone.now():%H:%M:%S}] Running {job_class_path}...")
+    return job_data
+
+
+def report_job_status(command, job_result):
+    # Report on success/failure
+    job_class_path = job_result.job_model.class_path
+    groups = set(JobLogEntry.objects.filter(job_result=job_result).values_list("grouping", flat=True))
+    for group in sorted(groups):
+        logs = JobLogEntry.objects.filter(job_result__pk=job_result.pk, grouping=group)
+        debug_count = logs.filter(log_level=LogLevelChoices.LOG_DEBUG).count()
+        info_count = logs.filter(log_level=LogLevelChoices.LOG_INFO).count()
+        warning_count = logs.filter(log_level=LogLevelChoices.LOG_WARNING).count()
+        error_count = logs.filter(log_level=LogLevelChoices.LOG_ERROR).count()
+        critical_count = logs.filter(log_level=LogLevelChoices.LOG_CRITICAL).count()
+
+        command.stdout.write(
+            f"\t{group}: {debug_count} debug, {info_count} info, {warning_count} warning, {error_count} error, {critical_count} critical"
+        )
+
+        for log_entry in logs:
+            status = log_entry.log_level
+            if status == "success":
+                status = command.style.SUCCESS(status)
+            elif status == "info":
+                status = status
+            elif status == "warning":
+                status = command.style.WARNING(status)
+            elif status == "failure":
+                status = command.style.NOTICE(status)
+
+            if log_entry.log_object:
+                command.stdout.write(f"\t\t{status}: {log_entry.log_object}: {log_entry.message}")
+            else:
+                command.stdout.write(f"\t\t{status}: {log_entry.message}")
+
+    if job_result.result:
+        command.stdout.write(str(job_result.result))
+
+    if job_result.status == JobResultStatusChoices.STATUS_FAILURE:
+        status = command.style.ERROR("FAILURE")
+    elif job_result.status == JobResultStatusChoices.STATUS_SUCCESS:
+        status = command.style.SUCCESS("SUCCESS")
+    else:
+        status = command.style.WARNING(job_result.status)
+    command.stdout.write(f"[{timezone.now():%H:%M:%S}] {job_class_path}: {status}")
+
+    # Wrap things up
+    command.stdout.write(f"[{timezone.now():%H:%M:%S}] {job_class_path}: Duration {job_result.duration}")
+    command.stdout.write(f"[{timezone.now():%H:%M:%S}] Finished")

nautobot/extras/managers.py

@@ -22,8 +22,9 @@ class JobResultManager(BaseManager.from_queryset(RestrictedQuerySet), TaskResult
             return self.model(id=task_id)
 
     @transaction_retry(max_retries=2)
-    def store_result(
+    def store_result(  # pylint:disable=arguments-differ  # Nautobot adds kwargs like job_model_id and scheduled_job_id
         self,
+        *,
         task_id,
         result,
         status,
@@ -41,6 +42,7 @@ class JobResultManager(BaseManager.from_queryset(RestrictedQuerySet), TaskResult
         using=None,
         content_type=None,
         content_encoding=None,
+        **kwargs,
     ):
         """
         Store the result and status of a Celery task.

nautobot/extras/migrations/0018_joblog_data_migration.py

@@ -2,7 +2,6 @@ from collections import OrderedDict
 
 from django.db import migrations
 
-from nautobot.extras.choices import LogLevelChoices
 from nautobot.extras.constants import (
     JOB_LOG_MAX_ABSOLUTE_URL_LENGTH,
     JOB_LOG_MAX_GROUPING_LENGTH,
@@ -123,14 +122,13 @@ def reverse_migrate_params(apps, schema_editor):
                 ]
             )
 
-            if entry.log_level != LogLevelChoices.LOG_DEFAULT:
-                job_result.data[entry.grouping].setdefault(entry.log_level, 0)
-                job_result.data[entry.grouping][entry.log_level] += 1
-                if "total" not in job_result.data:
-                    job_result.data["total"] = _data_grouping_struct()
-                    del job_result.data["total"]["log"]
-                job_result.data["total"].setdefault(entry.log_level, 0)
-                job_result.data["total"][entry.log_level] += 1
+            job_result.data[entry.grouping].setdefault(entry.log_level, 0)
+            job_result.data[entry.grouping][entry.log_level] += 1
+            if "total" not in job_result.data:
+                job_result.data["total"] = _data_grouping_struct()
+                del job_result.data["total"]["log"]
+            job_result.data["total"].setdefault(entry.log_level, 0)
+            job_result.data["total"][entry.log_level] += 1
 
             job_result.save()