secator 0.6.0__py3-none-any.whl → 0.8.0__py3-none-any.whl

secator/runners/_base.py

@@ -3,26 +3,20 @@ import logging
 import os
 import sys
 import uuid
-from contextlib import nullcontext
 from datetime import datetime
-from time import sleep, time
+from pathlib import Path
+from time import time
 
 import humanize
-from dotmap import DotMap
-from rich.padding import Padding
-from rich.panel import Panel
-from rich.progress import Progress as RichProgress
-from rich.progress import SpinnerColumn, TextColumn, TimeElapsedColumn
 
-from secator.definitions import DEBUG
+from secator.definitions import ADDONS_ENABLED
+from secator.celery_utils import CeleryData
 from secator.config import CONFIG
-from secator.output_types import OUTPUT_TYPES, OutputType, Progress
+from secator.output_types import FINDING_TYPES, OutputType, Progress, Info, Warning, Error, Target
 from secator.report import Report
 from secator.rich import console, console_stdout
-from secator.runners._helpers import (get_task_data, get_task_ids, get_task_folder_id,
-									  process_extractor)
-from secator.utils import (debug, import_dynamic, merge_opts, pluralize,
-						   rich_to_ansi)
+from secator.runners._helpers import (get_task_folder_id, process_extractor)
+from secator.utils import (debug, import_dynamic, merge_opts, rich_to_ansi, should_update)
 
 logger = logging.getLogger(__name__)
 
@@ -34,14 +28,12 @@ HOOKS = [
 	'on_item_pre_convert',
 	'on_item',
 	'on_duplicate',
-	'on_line',
-	'on_iter',
-	'on_error',
+	'on_interval',
 ]
 
 VALIDATORS = [
-	'input',
-	'item'
+	'validate_input',
+	'validate_item'
 ]
 
 
@@ -49,17 +41,16 @@ class Runner:
 	"""Runner class.
 
 	Args:
-		config (secator.config.TemplateLoader): Loaded config.
-		targets (list): List of targets to run task on.
-		results (list): List of existing results to re-use.
-		workspace_name (str): Workspace name.
-		run_opts (dict): Run options.
+		config (secator.config.TemplateLoader): Runner config.
+		inputs (List[str]): List of inputs to run task on.
+		results (List[OutputType]): List of results to re-use.
+		run_opts (dict[str]): Run options.
+		hooks (dict[str, List[Callable]]): User hooks to register.
+		validators (dict): User validators to register.
+		context (dict): Runner context.
 
 	Yields:
-		dict: Result (when running in sync mode with `run`).
-
-	Returns:
-		list: List of results (when running in async mode with `run_async`).
+		OutputType: Output types.
 	"""
 
 	# Input field (mostly for tests and CLI)
@@ -68,9 +59,6 @@ class Runner:
 	# Output types
 	output_types = []
 
-	# Dict return
-	output_return_type = dict  # TODO: deprecate this
-
 	# Default exporters
 	default_exporters = []
 
@@ -80,37 +68,38 @@ class Runner:
 	# Reports folder
 	reports_folder = None
 
-	def __init__(self, config, targets, results=[], run_opts={}, hooks={}, context={}):
+	def __init__(self, config, inputs=[], results=[], run_opts={}, hooks={}, validators={}, context={}):
 		self.config = config
 		self.name = run_opts.get('name', config.name)
 		self.description = run_opts.get('description', config.description)
-		if not isinstance(targets, list):
-			targets = [targets]
-		self.targets = targets
-		self.results = results
-		self.results_count = 0
+		if not isinstance(inputs, list):
+			inputs = [inputs]
+		self.inputs = inputs
+		self.uuids = []
+		self.output = ''
+		self.results = []
 		self.workspace_name = context.get('workspace_name', 'default')
 		self.run_opts = run_opts.copy()
 		self.sync = run_opts.get('sync', True)
 		self.done = False
 		self.start_time = datetime.fromtimestamp(time())
-		self.last_updated = None
+		self.last_updated_db = None
+		self.last_updated_celery = None
 		self.last_updated_progress = None
 		self.end_time = None
 		self._hooks = hooks
-		self.errors = []
-		self.infos = []
-		self.output = ''
-		self.status = 'RUNNING'
 		self.progress = 0
 		self.context = context
 		self.delay = run_opts.get('delay', False)
-		self.uuids = []
 		self.celery_result = None
+		self.celery_ids = []
+		self.celery_ids_map = {}
+		self.caller = self.run_opts.get('caller', None)
+		self.threads = []
 
 		# Determine exporters
 		exporters_str = self.run_opts.get('output') or self.default_exporters
-		self.exporters = Runner.resolve_exporters(exporters_str)
+		self.exporters = self.resolve_exporters(exporters_str)
 
 		# Determine report folder
 		default_reports_folder_base = f'{CONFIG.dirs.reports}/{self.workspace_name}/{self.config.type}s'
@@ -122,86 +111,67 @@ class Runner:
 		os.makedirs(f'{self.reports_folder}/.inputs', exist_ok=True)
 		os.makedirs(f'{self.reports_folder}/.outputs', exist_ok=True)
 
-		# Process input
-		self.input = targets
-		if isinstance(self.input, list) and len(self.input) == 1:
-			self.input = self.input[0]
-
-		# Yield dicts if CLI supports JSON
-		if self.output_return_type is dict or (self.json_flag is not None):
-			self.output_return_type = dict
-
-		# Output options
-		self.output_fmt = self.run_opts.get('format', False)
-		self.output_quiet = self.run_opts.get('quiet', False)
-		self.output_json = self.output_return_type == dict
-
-		# Print options
-		self.print_start = self.run_opts.pop('print_start', False)
-		self.print_item = self.run_opts.pop('print_item', False)
-		self.print_line = self.run_opts.pop('print_line', False)
-		self.print_errors = self.run_opts.pop('print_errors', True)
-		self.print_item_count = self.run_opts.pop('print_item_count', False)
-		self.print_cmd = self.run_opts.pop('print_cmd', False)
-		self.print_run_opts = self.run_opts.pop('print_run_opts', DEBUG > 1)
-		self.print_fmt_opts = self.run_opts.pop('print_fmt_opts', DEBUG > 1)
-		self.print_input_file = self.run_opts.pop('print_input_file', False)
-		self.print_hooks = self.run_opts.pop('print_hooks', DEBUG > 1)
-		self.print_progress = self.run_opts.pop('print_progress', not self.output_quiet)
-		self.print_cmd_prefix = self.run_opts.pop('print_cmd_prefix', False)
-		self.print_remote_status = self.run_opts.pop('print_remote_status', False)
-		self.print_run_summary = self.run_opts.pop('print_run_summary', False)
-		self.print_json = self.run_opts.get('json', False)
-		self.print_raw = self.run_opts.get('raw', False)
-		self.orig = self.run_opts.get('orig', False)
-		self.opts_to_print = {k: v for k, v in self.__dict__.items() if k.startswith('print_') if v}
+		# Profiler
+		self.enable_profiler = self.run_opts.get('enable_profiler', False) and ADDONS_ENABLED['trace']
+		if self.enable_profiler:
+			from pyinstrument import Profiler
+			self.profiler = Profiler(async_mode=False, interval=0.0001)
+			try:
+				self.profiler.start()
+			except RuntimeError:
+				self.enable_profiler = False
+				pass
+
+		# Process opts
+		self.quiet = self.run_opts.get('quiet', False)
+		self.no_process = self.run_opts.get('no_process', False)
+		self.piped_input = self.run_opts.get('piped_input', False)
+		self.piped_output = self.run_opts.get('piped_output', False)
+		self.enable_duplicate_check = self.run_opts.get('enable_duplicate_check', True)
+
+		# Print opts
+		self.print_item = self.run_opts.get('print_item', False)
+		self.print_line = self.run_opts.get('print_line', False) and not self.quiet
+		self.print_remote_info = self.run_opts.get('print_remote_info', False) and not self.piped_input and not self.piped_output  # noqa: E501
+		self.print_json = self.run_opts.get('print_json', False)
+		self.print_raw = self.run_opts.get('print_raw', False) or self.piped_output
+		self.print_fmt = self.run_opts.get('fmt', '')
+		self.print_progress = self.run_opts.get('print_progress', False) and not self.quiet and not self.print_raw
+		self.print_target = self.run_opts.get('print_target', False) and not self.quiet and not self.print_raw
+		self.print_stat = self.run_opts.get('print_stat', False) and not self.quiet and not self.print_raw
+		self.raise_on_error = self.run_opts.get('raise_on_error', not self.sync)
+		self.print_opts = {k: v for k, v in self.__dict__.items() if k.startswith('print_') if v}
+
+		# Debug
+		self.debug('Inputs', obj=self.inputs, sub='init')
+		self.debug('Run opts', obj={k: v for k, v in self.run_opts.items() if v is not None}, sub='init')
+		self.debug('Print opts', obj={k: v for k, v in self.print_opts.items() if v is not None}, sub='init')
 
 		# Hooks
-		self.raise_on_error = self.run_opts.get('raise_on_error', False)
-		self.hooks = {name: [] for name in HOOKS}
-		for key in self.hooks:
-
-			# Register class specific hooks
-			class_hook = getattr(self, key, None)
-			if class_hook:
-				name = f'{self.__class__.__name__}.{key}'
-				fun = self.get_func_path(class_hook)
-				debug('', obj={name + ' [dim yellow]->[/] ' + fun: 'registered'}, sub='hooks', level=3)
-				self.hooks[key].append(class_hook)
-
-			# Register user hooks
-			user_hooks = hooks.get(self.__class__, {}).get(key, [])
-			user_hooks.extend(hooks.get(key, []))
-			for hook in user_hooks:
-				name = f'{self.__class__.__name__}.{key}'
-				fun = self.get_func_path(hook)
-				debug('', obj={name + ' [dim yellow]->[/] ' + fun: 'registered (user)'}, sub='hooks', level=3)
-			self.hooks[key].extend(user_hooks)
+		self.hooks = {name: [] for name in HOOKS + getattr(self, 'hooks', [])}
+		self.register_hooks(hooks)
 
 		# Validators
-		self.validators = {name: [] for name in VALIDATORS}
-		for key in self.validators:
-			instance_func = getattr(self, f'validate_{key}', None)
-			if instance_func:
-				self.validators[key].append(instance_func)
-			self.validators[key].extend(self.validators.get(self.__class__, {}).get(key, []))
+		self.validators = {name: [] for name in VALIDATORS + getattr(self, 'validators', [])}
+		self.register_validators(validators)
 
 		# Chunks
-		self.parent = self.run_opts.get('parent', True)
+		self.has_parent = self.run_opts.get('has_parent', False)
 		self.has_children = self.run_opts.get('has_children', False)
 		self.chunk = self.run_opts.get('chunk', None)
 		self.chunk_count = self.run_opts.get('chunk_count', None)
 		self.unique_name = self.name.replace('/', '_')
 		self.unique_name = f'{self.unique_name}_{self.chunk}' if self.chunk else self.unique_name
-		self._set_print_prefix()
+
+		# Process prior results
+		for result in results:
+			list(self._process_item(result, print=False))
 
 		# Input post-process
 		self.run_hooks('before_init')
 
-		# Abort if inputs are invalid
-		self.input_valid = True
-		if not self.run_validators('input', self.input):
-			self.input_valid = False
+		# Check if input is valid
+		self.inputs_valid = self.run_validators('validate_input', self.inputs)
 
 		# Run hooks
 		self.run_hooks('on_init')
@@ -216,496 +186,480 @@ class Runner:
 	def elapsed_human(self):
 		return humanize.naturaldelta(self.elapsed)
 
+	@property
+	def targets(self):
+		return [r for r in self.results if isinstance(r, Target)]
+
+	@property
+	def infos(self):
+		return [r for r in self.results if isinstance(r, Info)]
+
+	@property
+	def warnings(self):
+		return [r for r in self.results if isinstance(r, Warning)]
+
+	@property
+	def errors(self):
+		return [r for r in self.results if isinstance(r, Error)]
+
+	@property
+	def self_results(self):
+		return [r for r in self.results if r._source.startswith(self.unique_name)]
+
+	@property
+	def findings(self):
+		return [r for r in self.results if isinstance(r, tuple(FINDING_TYPES))]
+
+	@property
+	def findings_count(self):
+		return len(self.findings)
+
+	@property
+	def self_findings(self):
+		return [r for r in self.results if isinstance(r, tuple(FINDING_TYPES)) if r._source.startswith(self.unique_name)]
+
+	@property
+	def self_findings_count(self):
+		return len(self.self_findings)
+
+	@property
+	def status(self):
+		if not self.done:
+			return 'RUNNING'
+		return 'FAILURE' if len(self.errors) > 0 else 'SUCCESS'
+
+	@property
+	def celery_state(self):
+		return {
+			'name': self.config.name,
+			'full_name': self.unique_name,
+			'state': self.status,
+			'progress': self.progress,
+			'results': self.self_results,
+			'chunk': self.chunk,
+			'chunk_count': self.chunk_count,
+			'chunk_info': f'{self.chunk}/{self.chunk_count}' if self.chunk and self.chunk_count else '',
+			'celery_id': self.context['celery_id'],
+			'count': self.self_findings_count,
+			'descr': self.config.description or '',
+		}
+
 	def run(self):
+		"""Run method.
+
+		Returns:
+			List[OutputType]: List of runner results.
+		"""
 		return list(self.__iter__())
 
 	def __iter__(self):
-		if self.print_start:
-			self.log_start()
+		"""Process results from derived runner class in real-time and yield results.
 
-		if not self.input_valid:
-			return
+		Yields:
+			OutputType: runner result.
+		"""
 		try:
-			for item in self.yielder():
-
-				if isinstance(item, (OutputType, DotMap, dict)):
-
-					# Handle direct yield of item
-					item = self._process_item(item)
-					if not item:
-						continue
-
-					# Discard item if needed
-					if item._uuid in self.uuids:
-						continue
-
-					# Add item to results
-					if isinstance(item, OutputType) or self.orig:
-						self.results.append(item)
-						self.results_count += 1
-						self.uuids.append(item._uuid)
-						yield item
-
-					# Print JSON or raw item
-					if self.print_item and item._type != 'target':
-						if not isinstance(item, OutputType) and not self.orig:
-							item_str = rich_to_ansi(
-								f'[dim red]❌ Failed to load item as output type:\n  {item.toDict()}[/]'
-							)
-							self.output += item_str + '\n'
-							self._print(item_str, rich=True)
-						elif self.print_json:
-							self._print(item, out=sys.stdout)
-						elif self.print_raw:
-							self._print(str(item), out=sys.stdout)
-						else:
-							item_str = self.get_repr(item)
-							if self.print_remote_status or DEBUG > 1:
-								item_str += f' [{item._source}]'
-							if item._type == 'progress' and not self.print_progress:
-								continue
-							self._print(item_str, out=sys.stdout)
-
-				elif item and isinstance(item, str):
-					if self.print_line:
-						self._print(item, out=sys.stderr, end='\n')
-					if not self.output_json:
-						self.results.append(item)
-						yield item
-
-				if item:
-					if isinstance(item, OutputType):
-						self.output += self.get_repr(item) + '\n'
-					else:
-						self.output += str(item) + '\n'
-
-				self.run_hooks('on_iter')
-
-		except KeyboardInterrupt:
-			self._print('Process was killed manually (CTRL+C / CTRL+X).', color='bold red', rich=True)
-			if self.celery_result:
-				self._print('Revoking remote Celery tasks ...', color='bold red', rich=True)
-				self.stop_live_tasks(self.celery_result)
-
-		# Filter results and log info
-		self.mark_duplicates()
-		self.results = self.filter_results()
+			self.log_start()
+			self.run_hooks('on_start')
+
+			# If any errors happened during valid ation, exit
+			if self.errors:
+				yield from self.errors
+				self.log_results()
+				self.run_hooks('on_end')
+				return
+
+			# Choose yielder
+			yielder = self.yielder_celery if self.celery_result else self.yielder
+
+			# Loop and process items
+			for item in yielder():
+				yield from self._process_item(item)
+				self.run_hooks('on_interval')
+
+			# Wait for threads to finish
+			yield from self.join_threads()
+
+		except BaseException as e:
+			self.debug(f'encountered exception {type(e).__name__}. Stopping remote tasks.', sub='error')
+			error = Error.from_exception(e)
+			error._source = self.unique_name
+			error._uuid = str(uuid.uuid4())
+			self.add_result(error, print=True)
+			self.stop_celery_tasks()
+			yield from self.join_threads()
+			yield error
+
+		# Mark duplicates and filter results
+		if not self.no_process:
+			self.mark_duplicates()
+			self.results = self.filter_results()
+
+		# Finalize run
 		self.log_results()
 		self.run_hooks('on_end')
 
+	def join_threads(self):
+		"""Wait for all running threads to complete."""
+		if not self.threads:
+			return
+		self.debug(f'waiting for {len(self.threads)} threads to complete')
+		for thread in self.threads:
+			error = thread.join()
+			if error:
+				error._source = self.unique_name
+				error._uuid = str(uuid.uuid4())
+				self.add_result(error, print=True)
+				yield error
+
+	def add_result(self, item, print=False):
+		"""Add item to runner results.
+
+		Args:
+			item (OutputType): Item.
+			print (bool): Whether to print it or not.
+		"""
+		self.uuids.append(item._uuid)
+		self.results.append(item)
+		self.output += repr(item) + '\n'
+		if print:
+			self._print_item(item)
+
+	def add_subtask(self, task_id, task_name, task_description):
+		"""Add a Celery subtask to the current runner for tracking purposes.
+
+		Args:
+			task_id (str): Celery task id.
+			task_name (str): Task name.
+			task_description (str): Task description.
+		"""
+		self.celery_ids.append(task_id)
+		self.celery_ids_map[task_id] = {
+			'id': task_id,
+			'name': task_name,
+			'full_name': task_name,
+			'descr': task_description,
+			'state': 'PENDING',
+			'count': 0,
+			'progress': 0
+		}
+
+	def _print_item(self, item, force=False):
+		"""Print an item and add it to the runner's output.
+
+		Args:
+			item (str | OutputType): Secator output type to print.
+			force (bool): Whether to force-print it.
+		"""
+		item_str = str(item)
+
+		# Item is an output type
+		if isinstance(item, OutputType):
+			self.debug(item, lazy=lambda x: repr(x), sub='item', allow_no_process=False, verbose=True)
+			_type = item._type
+			print_this_type = getattr(self, f'print_{_type}', True)
+			if not print_this_type:
+				return
+
+			if self.print_item or force:
+				item_out = sys.stdout
+
+				# JSON lines output
+				if self.print_json:
+					self._print(item, out=sys.stdout)
+					item_out = None  # suppress item repr output to sdout
+
+				# Raw output
+				elif self.print_raw:
+					item_out = sys.stderr if self.piped_output else None
+
+					# Format raw output with custom item fields
+					if self.print_fmt:
+						try:
+							item_str = item.format(**self.print_fmt)
+						except KeyError:
+							item_str = ''
+
+					# raw output is used to pipe, we should only pipe the first output type of a Runner.
+					if not isinstance(item, self.output_types[0]):
+						item_str = ''
+
+					if item_str:
+						self._print(item_str, out=sys.stdout)
+
+				# Repr output
+				if item_out:
+					item_repr = repr(item)
+					if isinstance(item, OutputType) and self.print_remote_info:
+						item_repr += rich_to_ansi(rf' \[[dim]{item._source}[/]]')
+					self._print(item_repr, out=item_out)
+
+		# Item is a line
+		elif isinstance(item, str):
+			self.debug(item, sub='line', allow_no_process=False, verbose=True)
+			if self.print_line or force:
+				self._print(item, out=sys.stderr, end='\n', rich=False)
+
+	def debug(self, *args, **kwargs):
+		"""Print debug with runner class name, only if self.no_process is True.
+
+		Args:
+			args (list): List of debug args.
+			kwargs (dict): Dict of debug kwargs.
+		"""
+		allow_no_process = kwargs.pop('allow_no_process', True)
+		if self.no_process and not allow_no_process:
+			return
+		sub = kwargs.get('sub')
+		new_sub = f'runner.{self.__class__.__name__}'
+		if sub:
+			new_sub += f'.{sub}'
+		kwargs['sub'] = new_sub
+		debug(*args, **kwargs)
+
 	def mark_duplicates(self):
-		debug('running duplicate check', id=self.config.name, sub='runner.mark_duplicates')
-		dupe_count = 0
-		for item in self.results:
-			# debug('running duplicate check', obj=item.toDict(), obj_breaklines=True, sub='runner.mark_duplicates', level=5)
-			others = [f for f in self.results if f == item and f._uuid != item._uuid]
-			if others:
-				main = max(item, *others)
-				dupes = [f for f in others if f._uuid != main._uuid]
-				main._duplicate = False
-				main._related.extend([dupe._uuid for dupe in dupes])
-				main._related = list(dict.fromkeys(main._related))
-				if main._uuid != item._uuid:
-					debug(f'found {len(others)} duplicates for', obj=item.toDict(), obj_breaklines=True, sub='runner.mark_duplicates', level=5)  # noqa: E501
-					item._duplicate = True
-					item = self.run_hooks('on_item', item)
-					if item._uuid not in main._related:
-						main._related.append(item._uuid)
-					main = self.run_hooks('on_duplicate', main)
-					item = self.run_hooks('on_duplicate', item)
-
-				for dupe in dupes:
-					if not dupe._duplicate:
-						debug(
-							'found new duplicate', obj=dupe.toDict(), obj_breaklines=True,
-							sub='runner.mark_duplicates', level=5)
-						dupe_count += 1
-						dupe._duplicate = True
-						dupe = self.run_hooks('on_duplicate', dupe)
-
-		duplicates = [repr(i) for i in self.results if i._duplicate]
-		if duplicates:
-			duplicates_str = '\n\t'.join(duplicates)
-			debug(f'Duplicates ({dupe_count}):\n\t{duplicates_str}', sub='runner.mark_duplicates', level=5)
-		debug(f'duplicate check completed: {dupe_count} found', id=self.config.name, sub='runner.mark_duplicates')
+		"""Check for duplicates and mark items as duplicates."""
+		if not self.enable_duplicate_check:
+			return
+		self.debug('running duplicate check', id=self.config.name, sub='duplicates')
+		# dupe_count = 0
+		import concurrent.futures
+		executor = concurrent.futures.ThreadPoolExecutor(max_workers=100)
+		for item in self.results.copy():
+			executor.submit(self.check_duplicate, item)
+		executor.shutdown(wait=True)
+		# duplicates = [repr(i) for i in self.results if i._duplicate]
+		# if duplicates:
+		# 	duplicates_str = '\n\t'.join(duplicates)
+		# 	self.debug(f'Duplicates ({dupe_count}):\n\t{duplicates_str}', sub='duplicates', verbose=True)
+		# self.debug(f'duplicate check completed: {dupe_count} found', id=self.config.name, sub='duplicates')
+
+	def check_duplicate(self, item):
+		"""Check if an item is a duplicate in the list of results and mark it like so.
+
+		Args:
+			item (OutputType): Secator output type.
+		"""
+		self.debug('running duplicate check for item', obj=item.toDict(), obj_breaklines=True, sub='duplicates', verbose=True)
+		others = [f for f in self.results if f == item and f._uuid != item._uuid]
+		if others:
+			main = max(item, *others)
+			dupes = [f for f in others if f._uuid != main._uuid]
+			main._duplicate = False
+			main._related.extend([dupe._uuid for dupe in dupes])
+			main._related = list(dict.fromkeys(main._related))
+			if main._uuid != item._uuid:
+				self.debug(f'found {len(others)} duplicates for', obj=item.toDict(), obj_breaklines=True, sub='duplicates', verbose=True)  # noqa: E501
+				item._duplicate = True
+				item = self.run_hooks('on_item', item)
+				if item._uuid not in main._related:
+					main._related.append(item._uuid)
+				main = self.run_hooks('on_duplicate', main)
+				item = self.run_hooks('on_duplicate', item)
+
+			for dupe in dupes:
+				if not dupe._duplicate:
+					self.debug(
+						'found new duplicate', obj=dupe.toDict(), obj_breaklines=True,
+						sub='duplicates', verbose=True)
+					# dupe_count += 1
+					dupe._duplicate = True
+					dupe = self.run_hooks('on_duplicate', dupe)
 
 	def yielder(self):
+		"""Yield results. Should be implemented by derived classes."""
 		raise NotImplementedError()
 
+	def yielder_celery(self):
+		"""Yield results from Celery result."""
+		yield from CeleryData.iter_results(
+			self.celery_result,
+			ids_map=self.celery_ids_map,
+			print_remote_info=False
+		)
+
 	def toDict(self):
-		return {
+		"""Dict representation of the runner."""
+		data = {
+			'name': self.name,
+			'status': self.status,
+			'targets': self.inputs,
+			'start_time': self.start_time,
+			'end_time': self.end_time,
+			'elapsed': self.elapsed.total_seconds(),
+			'elapsed_human': self.elapsed_human,
+			'run_opts': {k: v for k, v in self.run_opts.items() if k not in self.print_opts},
+		}
+		data.update({
 			'config': self.config.toDict(),
 			'opts': self.config.supported_opts,
-			'name': self.name,
-			'targets': self.targets,
-			'run_opts': self.run_opts,
-			'parent': self.parent,
+			'has_parent': self.has_parent,
 			'has_children': self.has_children,
 			'chunk': self.chunk,
 			'chunk_count': self.chunk_count,
-			'results_count': self.results_count,
 			'sync': self.sync,
 			'done': self.done,
 			'output': self.output,
-			'status': self.status,
 			'progress': self.progress,
-			'start_time': self.start_time,
-			'end_time': self.end_time,
-			'last_updated': self.last_updated,
-			'elapsed': self.elapsed.total_seconds(),
-			'elapsed_human': self.elapsed_human,
-			'errors': self.errors,
-			'context': self.context
-		}
+			'last_updated_db': self.last_updated_db,
+			'context': self.context,
+			'errors': [e.toDict() for e in self.errors],
+		})
+		return data
 
 	def run_hooks(self, hook_type, *args):
+		""""Run hooks of a certain type.
+
+		Args:
+			hook_type (str): Hook type.
+			args (list): List of arguments to pass to the hook.
+
+		Returns:
+			any: Hook return value.
+		"""
 		result = args[0] if len(args) > 0 else None
-		if not self.enable_hooks:
-			return result
+		_id = self.context.get('task_id', '') or self.context.get('workflow_id', '') or self.context.get('scan_id', '')
 		for hook in self.hooks[hook_type]:
 			name = f'{self.__class__.__name__}.{hook_type}'
 			fun = self.get_func_path(hook)
 			try:
-				_id = self.context.get('task_id', '') or self.context.get('workflow_id', '') or self.context.get('scan_id', '')
-				debug('', obj={name + ' [dim yellow]->[/] ' + fun: 'started'}, id=_id, sub='hooks', level=3)
+				if hook_type == 'on_interval' and not should_update(CONFIG.runners.backend_update_frequency, self.last_updated_db):
+					self.debug('', obj={f'{name} [dim yellow]->[/] {fun}': '[dim gray11]skipped[/]'}, id=_id, sub='hooks.db', verbose=True)  # noqa: E501
+					return
+				if not self.enable_hooks or self.no_process:
+					self.debug('', obj={f'{name} [dim yellow]->[/] {fun}': '[dim gray11]skipped[/]'}, id=_id, sub='hooks', verbose=True)  # noqa: E501
+					continue
+				# self.debug('', obj={f'{name} [dim yellow]->[/] {fun}': '[dim yellow]started[/]'}, id=_id, sub='hooks', verbose=True)  # noqa: E501
 				result = hook(self, *args)
-				debug('', obj={name + ' [dim yellow]->[/] ' + fun: 'ended'}, id=_id, sub='hooks', level=3)
+				self.debug('', obj={f'{name} [dim yellow]->[/] {fun}': '[dim green]success[/]'}, id=_id, sub='hooks', verbose=True)  # noqa: E501
 			except Exception as e:
+				self.debug('', obj={f'{name} [dim yellow]->[/] {fun}': '[dim red]failed[/]'}, id=_id, sub='hooks', verbose=True)  # noqa: E501
+				error = Error.from_exception(e)
+				error.message = f'Hook "{fun}" execution failed.'
+				error._source = self.unique_name
+				error._uuid = str(uuid.uuid4())
+				self.add_result(error, print=True)
 				if self.raise_on_error:
 					raise e
-				else:
-					if DEBUG > 1:
-						logger.exception(e)
-					else:
-						self._print(
-							f'{fun} failed: "{e.__class__.__name__}: {str(e)}". Skipping',
-							color='bold red',
-							rich=True)
-						self._print('Set DEBUG to > 1 to see the detailed exception.', color='dim red', rich=True)
 		return result
 
-	def run_validators(self, validator_type, *args):
-		# logger.debug(f'Running validators of type {validator_type}')
+	def run_validators(self, validator_type, *args, error=True):
+		"""Run validators of a certain type.
+
+		Args:
+			validator_type (str): Validator type. E.g: on_start.
+			args (list): List of arguments to pass to the validator.
+			error (bool): Whether to add an error to runner results if the validator failed.
+
+		Returns:
+			bool: Validator return value.
+		"""
+		if self.no_process:
+			return True
+		_id = self.context.get('task_id', '') or self.context.get('workflow_id', '') or self.context.get('scan_id', '')
 		for validator in self.validators[validator_type]:
-			# logger.debug(validator)
+			name = f'{self.__class__.__name__}.{validator_type}'
+			fun = self.get_func_path(validator)
 			if not validator(self, *args):
-				if validator_type == 'input':
-					self._print(f'{validator.__doc__}', color='bold red', rich=True)
+				self.debug('', obj={name + ' [dim yellow]->[/] ' + fun: '[dim red]failed[/]'}, id=_id, verbose=True, sub='validators')  # noqa: E501
+				doc = validator.__doc__
+				if error:
+					message = 'Validator failed'
+					if doc:
+						message += f': {doc}'
+					error = Error(
+						message=message,
+						_source=self.unique_name,
+						_uuid=str(uuid.uuid4())
+					)
+					self.add_result(error, print=True)
 				return False
+			self.debug('', obj={name + ' [dim yellow]->[/] ' + fun: '[dim green]success[/]'}, id=_id, verbose=True, sub='validators')  # noqa: E501
 		return True
 
-	@staticmethod
-	def resolve_exporters(exporters):
-		"""Resolve exporters from output options."""
-		if not exporters or exporters in ['false', 'False']:
-			return []
-		if isinstance(exporters, str):
-			exporters = exporters.split(',')
-		classes = [
-			import_dynamic(f'secator.exporters.{o.capitalize()}Exporter', 'Exporter')
-			for o in exporters
-			if o
-		]
-		return [cls for cls in classes if cls]
+	def register_hooks(self, hooks):
+		"""Register hooks.
 
-	def log_start(self):
-		"""Log runner start."""
-		remote_str = 'starting' if self.sync else 'sent to Celery worker'
-		runner_name = self.__class__.__name__
-		self.log_header()
-		self._print(
-			f':tada: {runner_name} [bold magenta]{self.config.name}[/] {remote_str}...', rich=True)
-		if not self.sync and self.print_remote_status and self.__class__.__name__ != 'Scan':
-			self._print('\n🏆 [bold gold3]Live results:[/]', rich=True)
-
-	def log_header(self):
-		"""Log runner header."""
-		runner_name = self.__class__.__name__
+		Args:
+			hooks (dict[str, List[Callable]]): List of hooks to register.
+		"""
+		for key in self.hooks:
+			# Register class + derived class hooks
+			class_hook = getattr(self, key, None)
+			if class_hook:
+				name = f'{self.__class__.__name__}.{key}'
+				fun = self.get_func_path(class_hook)
+				self.debug('', obj={name + ' [dim yellow]->[/] ' + fun: 'registered'}, sub='hooks')
+				self.hooks[key].append(class_hook)
 
-		# Description
-		panel_str = f':scroll: [bold gold3]Description:[/] {self.config.description}'
+			# Register user hooks
+			user_hooks = hooks.get(self.__class__, {}).get(key, [])
+			user_hooks.extend(hooks.get(key, []))
+			for hook in user_hooks:
+				name = f'{self.__class__.__name__}.{key}'
+				fun = self.get_func_path(hook)
+				self.debug('', obj={name + ' [dim yellow]->[/] ' + fun: 'registered (user)'}, sub='hooks')
+			self.hooks[key].extend(user_hooks)
 
-		# Workspace
-		if self.workspace_name:
-			panel_str += f'\n:construction_worker: [bold gold3]Workspace:[/] {self.workspace_name}'
+	def register_validators(self, validators):
+		"""Register validators.
 
-		# Targets
-		if self.targets:
-			panel_str += '\n:pear: [bold gold3]Targets:[/]'
-			for target in self.targets:
-				panel_str += f'\n   • {target}'
+		Args:
+			validators (dict[str, List[Callable]]): Validators to register.
+		"""
+		# Register class + derived class hooks
+		for key in self.validators:
+			class_validator = getattr(self, key, None)
+			if class_validator:
+				name = f'{self.__class__.__name__}.{key}'
+				fun = self.get_func_path(class_validator)
+				self.validators[key].append(class_validator)
+				self.debug('', obj={name + ' [dim yellow]->[/] ' + fun: 'registered'}, sub='validators')
 
-		# Options
-		DISPLAY_OPTS_EXCLUDE = [
-			'sync', 'worker', 'debug', 'output', 'json', 'orig', 'raw', 'format', 'quiet'
-		]
-		items = [
-			f'[italic]{k}[/]: {v}'
-			for k, v in self.run_opts.items()
-			if k not in DISPLAY_OPTS_EXCLUDE
-			and v is not None
-		]
-		if items:
-			panel_str += '\n:pushpin: [bold gold3]Options:[/]'
-			for item in items:
-				panel_str += f'\n   • {item}'
-
-		if self.exporters:
-			panel_str += '\n:email:  [bold gold3]Exporters:[/]'
-			for exporter in self.exporters:
-				exporter_name = exporter.__name__.replace('Exporter', '').lower()
-				panel_str += f'\n   • {exporter_name}'
-
-		panel = Panel(
-			panel_str,
-			title=f'[bold gold3]{runner_name}[/] [bold magenta]{self.config.name}[/]',
-			border_style='bold gold3',
-			expand=False,
-			highlight=True
-		)
-		self._print('\n')
-		self._print(panel, rich=True)
+			# Register user hooks
+			user_validators = validators.get(key, [])
+			for validator in user_validators:
+				name = f'{self.__class__.__name__}.{key}'
+				fun = self.get_func_path(validator)
+				self.debug('', obj={name + ' [dim yellow]->[/] ' + fun: 'registered (user)'}, sub='validators')
+			self.validators[key].extend(user_validators)
 
-	def log_results(self):
-		"""Log results.
+	def log_start(self):
+		"""Log runner start."""
+		if not self.print_remote_info:
+			return
+		remote_str = 'starting' if self.sync else 'sent to Celery worker'
+		runner_name = self.__class__.__name__
+		info = Info(message=f'{runner_name} [bold magenta]{self.config.name}[/] {remote_str}...', _source=self.unique_name)
+		self._print_item(info)
 
-		Args:
-			results (list): List of results.
-			output_types (list): List of result types to add to report.
-		"""
+	def log_results(self):
+		"""Log runner results."""
 		self.done = True
 		self.progress = 100
-		self.results_count = len(self.results)
-		self.status = 'SUCCESS' if not self.errors else 'FAILED'
 		self.end_time = datetime.fromtimestamp(time())
-
-		# Log execution results
-		status = 'succeeded' if not self.errors else '[bold red]failed[/]'
-		if self.print_run_summary:
-			self._print('\n')
-			self._print(
-				f':tada: [bold green]{self.__class__.__name__.capitalize()}[/] [bold magenta]{self.config.name}[/] '
-				f'[bold green]{status} in[/] [bold gold3]{self.elapsed_human}[/].', rich=True)
-
-		# Log runner infos
-		if self.infos:
-			self._print(
-				f':heavy_check_mark: [bold magenta]{self.config.name}[/] infos ({len(self.infos)}):',
-				color='bold green', rich=True)
-			for info in self.infos:
-				self._print(f'   • {info}', color='bold green', rich=True)
-
-		# Log runner errors
-		if self.errors and self.print_errors:
-			self._print(
-				f':exclamation_mark:[bold magenta]{self.config.name}[/] errors ({len(self.errors)}):',
-				color='bold red', rich=True)
-			for error in self.errors:
-				self._print(f'   • {error}', color='bold red', rich=True)
-
-		# Build and send report
-		if self.results:
+		if self.status == 'FAILURE':
+			self.debug('', obj={self.__class__.__name__: self.status, 'errors': [str(_.message) for _ in self.errors]}, sub='status')  # noqa: E501
+		else:
+			self.debug('', obj={self.__class__.__name__: self.status}, sub='status')
+		if self.exporters and not self.no_process:
 			report = Report(self, exporters=self.exporters)
 			report.build()
 			report.send()
 			self.report = report
-
-		# Log results count
-		if self.print_item_count and not self.print_raw and not self.orig:
-			count_map = self._get_results_count()
-			if all(count == 0 for count in count_map.values()):
-				self._print(':exclamation_mark:Found 0 results.', color='bold red', rich=True)
-			else:
-				results_str = ':heavy_check_mark: Found ' + ' and '.join([
-					f'{count} {pluralize(name) if count > 1 or count == 0 else name}'
-					for name, count in count_map.items()
-				]) + '.'
-				self._print(results_str, color='bold green', rich=True)
-
-	@staticmethod
-	def get_live_results(result):
-		"""Poll Celery subtasks results in real-time. Fetch task metadata and partial results from each task that runs.
-
-		Args:
-			result (celery.result.AsyncResult): Result object.
-
-		Yields:
-			dict: Subtasks state and results.
-		"""
-		from celery.result import AsyncResult
-		res = AsyncResult(result.id)
-		while True:
-			# Yield results
-			yield from Runner.get_celery_results(result)
-
-			# Break out of while loop
-			if res.ready():
-				yield from Runner.get_celery_results(result)
-				break
-
-			# Sleep between updates
-			sleep(1)
-
-	@staticmethod
-	def get_celery_results(result):
-		"""Get Celery results from main result object, including any subtasks results.
-
-		Args:
-			result (celery.result.AsyncResult): Result object.
-
-		Yields:
-			dict: Subtasks state and results, Progress objects.
-		"""
-		task_ids = []
-		get_task_ids(result, ids=task_ids)
-		datas = []
-		for task_id in task_ids:
-			data = get_task_data(task_id)
-			if data and DEBUG > 1:
-				full_name = data['name']
-				if data['chunk_info']:
-					full_name += ' ' + data['chunk_info']
-				debug('', sub='celery.runner', id=data['id'], obj={full_name: data['state']}, level=4)
-			if not data:
-				continue
-			yield data
-			datas.append(data)
-
-		# Calculate and yield progress
-		total = len(datas)
-		count_finished = sum([i['ready'] for i in datas if i])
-		percent = int(count_finished * 100 / total) if total > 0 else 0
-		if percent > 0:
-			yield Progress(duration='unknown', percent=percent)
-
-	def stop_live_tasks(self, result):
-		"""Stop live tasks running in Celery worker.
-
-		Args:
-			result (AsyncResult | GroupResult): Celery result.
-		"""
-		task_ids = []
-		get_task_ids(result, ids=task_ids)
-		for task_id in task_ids:
-			from secator.celery import revoke_task
-			revoke_task(task_id)
-
-	def process_live_tasks(self, result, description=True, results_only=True, print_remote_status=True):
-		"""Rich progress indicator showing live tasks statuses.
-
-		Args:
-			result (AsyncResult | GroupResult): Celery result.
-			results_only (bool): Yield only results, no task state.
-
-		Yields:
-			dict: Subtasks state and results.
-		"""
-		config_name = self.config.name
-		runner_name = self.__class__.__name__.capitalize()
-
-		# Display live results if print_remote_status is set
-		if print_remote_status:
-			class PanelProgress(RichProgress):
-				def get_renderables(self):
-					yield Padding(Panel(
-						self.make_tasks_table(self.tasks),
-						title=f'[bold gold3]{runner_name}[/] [bold magenta]{config_name}[/] results',
-						border_style='bold gold3',
-						expand=False,
-						highlight=True), pad=(2, 0, 0, 0))
-
-			tasks_progress = PanelProgress(
-				SpinnerColumn('dots'),
-				TextColumn('{task.fields[descr]}  ') if description else '',
-				TextColumn('[bold cyan]{task.fields[name]}[/]'),
-				TextColumn('[dim gold3]{task.fields[chunk_info]}[/]'),
-				TextColumn('{task.fields[state]:<20}'),
-				TimeElapsedColumn(),
-				TextColumn('{task.fields[count]}'),
-				# TextColumn('{task.fields[progress]}%'),
-				# TextColumn('\[[bold magenta]{task.fields[id]:<30}[/]]'),  # noqa: W605
-				refresh_per_second=1,
-				transient=False,
-				# console=console,
-				# redirect_stderr=True,
-				# redirect_stdout=False
-			)
-			state_colors = {
-				'RUNNING': 'bold yellow',
-				'SUCCESS': 'bold green',
-				'FAILURE': 'bold red',
-				'REVOKED': 'bold magenta'
-			}
-		else:
-			tasks_progress = nullcontext()
-
-		with tasks_progress as progress:
-
-			# Make progress tasks
-			tasks_progress = {}
-
-			# Get live results and print progress
-			for data in Runner.get_live_results(result):
-
-				# If progress object, yield progress and ignore tracking
-				if isinstance(data, OutputType) and data._type == 'progress':
-					yield data
-					continue
-
-				# TODO: add error output type and yield errors in get_celery_results
-				# if isinstance(data, OutputType) and data._type == 'error':
-				# 	yield data
-				# 	continue
-
-				# Re-yield so that we can consume it externally
-				if results_only:
-					yield from data['results']
-				else:
-					yield data
-
-				if not print_remote_status:
-					continue
-
- 				# Ignore partials in output unless DEBUG > 1
-				# TODO: weird to change behavior based on debug flag, could cause issues
-				# if data['chunk'] and not DEBUG > 1:
-				# 	continue
-
-				# Handle messages if any
-				state = data['state']
-				error = data.get('error')
-				info = data.get('info')
-				full_name = data['name']
-				chunk_info = data.get('chunk_info', '')
-				if chunk_info:
-					full_name += f' {chunk_info}'
-				if error:
-					state = 'FAILURE'
-					error = f'{full_name}: {error}'
-					if error not in self.errors:
-						self.errors.append(error)
-				if info:
-					info = f'{full_name}: {info}'
-					if info not in self.infos:
-						self.infos.append(info)
-
-				task_id = data['id']
-				state_str = f'[{state_colors[state]}]{state}[/]'
-				data['state'] = state_str
-
-				if task_id not in tasks_progress:
-					id = progress.add_task('', **data)
-					tasks_progress[task_id] = id
-				else:
-					progress_id = tasks_progress[task_id]
-					if state in ['SUCCESS', 'FAILURE']:
-						progress.update(progress_id, advance=100, **data)
-					elif data['progress'] != 0:
-						progress.update(progress_id, advance=data['progress'], **data)
-
-			# Update all tasks to 100 %
-			for progress_id in tasks_progress.values():
-				progress.update(progress_id, advance=100)
+		if self.enable_profiler:
+			self.profiler.stop()
+			profile_path = Path(self.reports_folder) / f'{self.unique_name}_profile.html'
+			with profile_path.open('w', encoding='utf-8') as f_html:
+				f_html.write(self.profiler.output_html())
+			self._print_item(Info(message=f'Wrote profile to {str(profile_path)}', _source=self.unique_name), force=True)
+
+	def stop_celery_tasks(self):
+		"""Stop all tasks running in Celery worker."""
+		from secator.celery import revoke_task
+		for task_id in self.celery_ids:
+			name = self.celery_ids_map.get(task_id, {}).get('full_name')
+			revoke_task(task_id, name)
 
 	def filter_results(self):
 		"""Filter runner results using extractors defined in config."""
@@ -721,7 +675,7 @@ class Runner:
 			# Keep the field types in results not specified in the extractors.
 			extract_fields = [e['type'] for e in extractors]
 			keep_fields = [
-				_type for _type in OUTPUT_TYPES if _type.__name__ != 'Progress'
+				_type for _type in FINDING_TYPES
 				if _type not in extract_fields
 			]
 			results.extend([
@@ -733,41 +687,61 @@ class Runner:
 		return results
 
 	def _convert_item_schema(self, item):
-		"""Convert dict item to a new structure using the class output schema.
+		"""Convert dict item to a secator output type.
 
 		Args:
-			item (dict): Item.
+			item (dict): Dict item.
 
 		Returns:
-			dict: Item with new schema.
+			OutputType: Loaded item.
 		"""
-		# Load item using available output types and get the first matching
-		# output type based on the schema
+		# Skip if already converted
+		if isinstance(item, OutputType):
+			return item
+
+		# Init the new item and the list of output types to load from
 		new_item = None
 		output_types = getattr(self, 'output_types', [])
-		debug(f'Input item: {item}', sub='klass.load', level=5)
-		debug(f'Output types to try: {[o.__name__ for o in output_types]}', sub='klass.load', level=5)
+		self.debug(f'Input item: {item}', sub='klass.load', verbose=True)
+
+		# Use a function to pick proper output types
+		output_discriminator = getattr(self, 'output_discriminator', None)
+		if output_discriminator:
+			result = output_discriminator(item)
+			if result:
+				self.debug(f'Discriminated output type: {result.__name__}', sub='klass.load', verbose=True)
+				output_types = [result]
+			else:
+				output_types = []
+
+		# Use the _type key to pick proper output type
+		elif '_type' in item:
+			otypes = [o for o in output_types if o.get_name() == item['_type']]
+			if otypes:
+				output_types = [otypes[0]]
+				self.debug(f'_type key is present in item and matches {otypes[0]}', sub='klass.load', verbose=True)
+
+		# Load item using picked output types
+		self.debug(f'Output types to try: {[o.__name__ for o in output_types]}', sub='klass.load', verbose=True)
 		for klass in output_types:
-			debug(f'Loading item as {klass.__name__}', sub='klass.load', level=5)
-			output_map = getattr(self, 'output_map', {})
-			output_map = output_map.get(klass, {})
+			self.debug(f'Loading item as {klass.__name__}', sub='klass.load', verbose=True)
+			output_map = getattr(self, 'output_map', {}).get(klass, {})
 			try:
 				new_item = klass.load(item, output_map)
-				debug(f'[dim green]Successfully loaded item as {klass.__name__}[/]', sub='klass.load', level=5)
-				break  # found an item that fits
-			except (TypeError, KeyError) as e:  # can't load using class
-				debug(
+				self.debug(f'[dim green]Successfully loaded item as {klass.__name__}[/]', sub='klass.load', verbose=True)
+				break
+			except (TypeError, KeyError) as e:
+				self.debug(
 					f'[dim red]Failed loading item as {klass.__name__}: {type(e).__name__}: {str(e)}.[/] [dim green]Continuing.[/]',
-					sub='klass.load',
-					level=5)
-				if DEBUG == 6:
-					console.print_exception(show_locals=False)
+					sub='klass.load', verbose=True)
+				# error = Error.from_exception(e)
+				# self.debug(repr(error), sub='debug.klass.load')
 				continue
 
-		# No output type was found, so make no conversion
 		if not new_item:
-			new_item = DotMap(item)
-			new_item._type = 'unknown'
+			new_item = Warning(message=f'Failed to load item as output type:\n  {item}')
+
+		self.debug(f'Output item: {new_item.toDict()}', sub='klass.load', verbose=True)
 
 		return new_item
 
@@ -779,113 +753,130 @@ class Runner:
 			color (str, Optional): Rich color.
 			out (str, Optional): Output pipe (sys.stderr, sys.stdout, ...)
 			rich (bool, Optional): Force rich output.
+			end (str, Optional): End of line.
+			add_to_output (bool, Optional): Whether to add the item to runner output.
 		"""
-		# Print a JSON item
-		if isinstance(data, (OutputType, DotMap, dict)):
-			if getattr(data, 'toDict', None):
-				data = data.toDict()
-			data = json.dumps(data)
-			data = f'{self.prefix:>15} {data}' if self.prefix and not self.print_item else data
-
-		if self.sync or rich:
+		if rich:
 			_console = console_stdout if out == sys.stdout else console
 			_console.print(data, highlight=False, style=color, soft_wrap=True, end=end)
 		else:
+			if isinstance(data, (OutputType, dict)):
+				if getattr(data, 'toDict', None):
+					data = data.toDict()
+				data = json.dumps(data)
 			print(data, file=out)
 
-		# # Print a line using Rich console
-		# if rich:
-		# 	_console = console_stdout if out == sys.stdout else console
-		# 	_console.print(data, highlight=False, style=color, soft_wrap=True)
-
-		# # Print a line using Rich markup
-		# elif markup:
-		# 	from rich import print as _print
-		# 	from rich.text import Text
-		# 	_print(Text.from_markup(data), file=out)
-
-		# # Print a line raw
-		# else:
-		# 	print(data, file=out)
-
-	def _set_print_prefix(self):
-		self.prefix = ''
-		if self.print_cmd_prefix:
-			self.prefix = f'[bold gold3]({self.config.name})[/]'
-		if self.chunk and self.chunk_count:
-			self.prefix += f' [{self.chunk}/{self.chunk_count}]'
-
-	def _get_results_count(self):
+	def _get_findings_count(self):
+		"""Get finding count.
+
+		Returns:
+			dict[str,int]: Dict of finding type to count.
+		"""
 		count_map = {}
-		for output_type in self.output_types:
-			if output_type.__name__ == 'Progress':
-				continue
+		for output_type in FINDING_TYPES:
 			name = output_type.get_name()
-			count = len([r for r in self.results if r._type == name])
-			count_map[name] = count
+			count = len([r for r in self.results if isinstance(r, output_type)])
+			if count > 0:
+				count_map[name] = count
 		return count_map
 
-	def _process_item(self, item: dict):
-		# Run item validators
-		if not self.run_validators('item', item):
-			return None
+	def _process_item(self, item, print=True):
+		"""Process an item yielded by the derived runner.
+
+		Args:
+			item (dict | str): Input item.
+			print (bool): Print item in console.
+
+		Yields:
+			OutputType: Output type.
+		"""
+		# Item is a string, just print it
+		if isinstance(item, str):
+			self.output += item + '\n'
+			self._print_item(item) if item and print else ''
+			return
+
+		# Abort further processing if no_process is set
+		if self.no_process:
+			return
 
-		# Run item hooks
-		item = self.run_hooks('on_item_pre_convert', item)
-		if not item:
-			return None
+		# Run item validators
+		if not self.run_validators('validate_item', item, error=False):
+			return
 
 		# Convert output dict to another schema
-		if isinstance(item, dict) and not self.orig:
+		if isinstance(item, dict):
+			item = self.run_hooks('on_item_pre_convert', item)
+			if not item:
+				return
 			item = self._convert_item_schema(item)
-		elif isinstance(item, OutputType):
-			pass
-		else:
-			item = DotMap(item)
 
 		# Update item context
 		item._context.update(self.context)
 
-		# Add context, uuid, progress to item
-		if not item._source:
-			item._source = self.config.name
+		# Return if already seen
+		if item._uuid in self.uuids:
+			return
 
+		# Add uuid to item
 		if not item._uuid:
 			item._uuid = str(uuid.uuid4())
 
-		if item._type == 'progress' and item._source == self.config.name:
+		# Add source to item
+		if not item._source:
+			item._source = self.unique_name
+
+		# If progress item, update runner progress
+		if isinstance(item, Progress) and item._source == self.unique_name:
 			self.progress = item.percent
-			update_frequency = CONFIG.runners.progress_update_frequency
-			if self.last_updated_progress and (item._timestamp - self.last_updated_progress) < update_frequency:
-				return None
+			if not should_update(CONFIG.runners.progress_update_frequency, self.last_updated_progress, item._timestamp):
+				return
 			elif int(item.percent) in [0, 100]:
-				return None
+				return
 			else:
 				self.last_updated_progress = item._timestamp
 
-		# Run on_item hooks
-		if isinstance(item, OutputType) and not self.orig:
+		# If info item and task_id is defined, update runner celery_ids
+		elif isinstance(item, Info) and item.task_id and item.task_id not in self.celery_ids:
+			self.celery_ids.append(item.task_id)
+
+		# If finding, run on_item hooks
+		elif isinstance(item, tuple(FINDING_TYPES)):
 			item = self.run_hooks('on_item', item)
+			if not item:
+				return
 
-		return item
+		# Add item to results
+		self.add_result(item, print=print)
 
-	def get_repr(self, item=None):
-		if not item:
-			return [
-				self.get_repr(item)
-				for item in self.results
-			]
-		if self.output_fmt:
-			item = self.output_fmt.format(**item.toDict())
-		elif isinstance(item, OutputType):
-			item = repr(item)
-		return item
+		# Yield item
+		yield item
+
+	@staticmethod
+	def resolve_exporters(exporters):
+		"""Resolve exporters from output options.
+
+		Args:
+			exporters (list[str]): List of exporters to resolve.
+
+		Returns:
+			list: List of exporter classes.
+		"""
+		if not exporters or exporters in ['false', 'False']:
+			return []
+		if isinstance(exporters, str):
+			exporters = exporters.split(',')
+		classes = [
+			import_dynamic('secator.exporters', f'{o.capitalize()}Exporter')
+			for o in exporters
+			if o
+		]
+		return [cls for cls in classes if cls]
 
 	@classmethod
 	def get_func_path(cls, func):
-		"""
-		Get the full symbolic path of a function or method, including staticmethods,
-		using function and method attributes.
+		"""Get the full symbolic path of a function or method, including staticmethods, using function and method
+		attributes.
 
 		Args:
 			func (function, method, or staticmethod): A function or method object.