stoobly-agent 0.34.9__py3-none-any.whl → 0.34.11__py3-none-any.whl

stoobly_agent/__init__.py

@@ -1,2 +1,2 @@
 COMMAND = 'stoobly-agent'
-VERSION = '0.34.9'
+VERSION = '0.34.11'

stoobly_agent/app/api/proxy_controller.py

@@ -7,6 +7,8 @@ from stoobly_agent.config.constants import headers
 from stoobly_agent.config.mitmproxy import MitmproxyConfig
 from stoobly_agent.lib.logger import Logger
 
+LOG_ID = 'ProxyController'
+
 class ProxyController:
     _instance = None
 
@@ -54,14 +56,14 @@ class ProxyController:
             _params = context.params
             _verify = not MitmproxyConfig.instance().get('ssl_insecure')
 
-            Logger.instance().debug('Request Headers')
-            Logger.instance().debug(_headers)
-            Logger.instance().debug('Cookies')
-            Logger.instance().debug(_cookies)
-            Logger.instance().debug('Body')
-            Logger.instance().debug(_body)
-            Logger.instance().debug('Query Params')
-            Logger.instance().debug(_params)
+            Logger.instance(LOG_ID).debug('Request Headers')
+            Logger.instance(LOG_ID).debug(_headers)
+            Logger.instance(LOG_ID).debug('Cookies')
+            Logger.instance(LOG_ID).debug(_cookies)
+            Logger.instance(LOG_ID).debug('Body')
+            Logger.instance(LOG_ID).debug(_body)
+            Logger.instance(LOG_ID).debug('Query Params')
+            Logger.instance(LOG_ID).debug(_params)
 
             body = None
             headers = {}
@@ -99,8 +101,8 @@ class ProxyController:
                 body = b'Unknown Error'
                 status = 0
 
-            Logger.instance().debug('Response Headers')
-            Logger.instance().debug(res.headers)
+            Logger.instance(LOG_ID).debug('Response Headers')
+            Logger.instance(LOG_ID).debug(res.headers)
 
             context.render(
                 headers = headers,

stoobly_agent/app/cli/config_cli.py

@@ -23,6 +23,8 @@ from .helpers.handle_config_update_service import (
 from .helpers.print_service import FORMATS, print_projects, print_scenarios, select_print_options
 from .helpers.validations import *
 
+LOG_ID = 'ConfigCLI'
+
 settings = Settings.instance()
 is_remote = settings.cli.features.remote or not not os.environ.get(env_vars.FEATURE_REMOTE)
 
@@ -261,7 +263,7 @@ def set(**kwargs):
 
     settings.commit()
 
-    Logger.instance().debug(f"Rewrite {kwargs['name']} -> {kwargs['value']} set!")
+    Logger.instance(LOG_ID).debug(f"Rewrite {kwargs['name']} -> {kwargs['value']} set!")
 
 ### Match
 
@@ -326,7 +328,7 @@ def set(**kwargs):
 
     settings.commit()
 
-    Logger.instance().debug(f"Match {kwargs['method']} {kwargs['pattern']} -> {kwargs['component']} set!")
+    Logger.instance(LOG_ID).debug(f"Match {kwargs['method']} {kwargs['pattern']} -> {kwargs['component']} set!")
 
 ### Firewall
 
@@ -392,7 +394,7 @@ def set(**kwargs):
 
     settings.commit()
 
-    Logger.instance().debug(f"Firewall {kwargs['method']} {kwargs['pattern']} -> {kwargs['action']} set!")
+    Logger.instance(LOG_ID).debug(f"Firewall {kwargs['method']} {kwargs['pattern']} -> {kwargs['action']} set!")
 
 ### Validate
 

stoobly_agent/app/cli/helpers/handle_config_update_service.py

@@ -56,6 +56,11 @@ def handle_intercept_active_update(new_settings: Settings, context: Context = No
           # If policy is overwrite when recording, whenever intercept is disabled,
           # set active scenario to not be overwritable
           scenario_model.update(_scenario_key.id, **{ 'overwritable': False })[1]
+    elif _mode == intercept_mode.MOCK:
+      # When mock is stopped, clear request access counts
+      from stoobly_agent.app.models.factories.resource.local_db.helpers.tiebreak_scenario_request import reset
+
+      reset()
 
 def handle_scenario_update(new_settings: Settings, context = None):
   new_scenario_key = __scenario_key(new_settings.proxy)

stoobly_agent/app/cli/snapshot_cli.py

@@ -11,24 +11,26 @@ from typing import List
 
 from stoobly_agent.app.models.adapters.raw_joined import RawJoinedRequestAdapterFactory
 from stoobly_agent.app.models.factories.resource.local_db.helpers.log import Log
-from stoobly_agent.app.models.factories.resource.local_db.helpers.log_event import LogEvent, REQUEST_RESOURCE, SCENARIO_RESOURCE
+from stoobly_agent.app.models.factories.resource.local_db.helpers.log_event import LogEvent, PUT_ACTION, REQUEST_RESOURCE, SCENARIO_RESOURCE
 from stoobly_agent.app.models.factories.resource.local_db.helpers.request_snapshot import RequestSnapshot
 from stoobly_agent.app.models.factories.resource.local_db.helpers.scenario_snapshot import ScenarioSnapshot
 from stoobly_agent.app.models.helpers.apply import Apply
+from stoobly_agent.config.data_dir import DataDir
+from stoobly_agent.lib.api.keys import RequestKey, ScenarioKey
 
 from .helpers.print_service import FORMATS, print_snapshots, select_print_options
 from .helpers.verify_raw_request_service import verify_raw_request
 
 @click.group(
     epilog="Run 'stoobly-agent project COMMAND --help' for more information on a command.",
-    help="Manage snapshots"
+    help="Manage snapshots."
 )
 @click.pass_context
 def snapshot(ctx):
     pass
 
 @snapshot.command(
-  help="Apply snapshots",
+  help="Apply snapshots.",
 )
 @click.option('--force', default=False, help="Toggles whether resources are hard deleted.")
 @click.argument('uuid', required=False)
@@ -41,7 +43,18 @@ def apply(**kwargs):
     apply.all()
 
 @snapshot.command(
-  help="List snapshots",
+  help="Copy snapshots to a different data directory."
+)
+@click.option('--request-key', multiple=True, help='')
+@click.option('--scenario-key', multiple=True, help='')
+@click.argument('destination', required=True)
+def copy(**kwargs):
+  destination = kwargs['destination']
+  __copy_scenarios(kwargs['scenario_key'], destination)
+  __copy_requests(kwargs['request_key'], destination)
+
+@snapshot.command(
+  help="List snapshots.",
   name="list"
 )
 @click.option('--format', type=click.Choice(FORMATS), help='Format output.')
@@ -83,7 +96,7 @@ def prune(**kwargs):
   log.prune(kwargs['dry_run'])
 
 @snapshot.command(
-  help="Update snapshot",
+  help="Update snapshot.",
 )
 @click.option('--format', type=click.Choice(FORMATS), help='Format output.')
 @click.option('--select', multiple=True, help='Select column(s) to display.')
@@ -266,4 +279,70 @@ def __transform_scenario(snapshot: ScenarioSnapshot):
   event_dict['name'] = metadata.get('name')
   event_dict['description'] = metadata.get('description')
 
-  return event_dict
+  return event_dict
+
+def __copy_requests(request_keys: list, destination: str):
+  log = Log()
+
+  data_dir = DataDir.instance(destination)
+  destination_log = Log(data_dir)
+
+  for request_key in request_keys:
+    found = False
+
+    for event in log.target_events:
+      if event.action != PUT_ACTION:
+        continue
+
+      if event.resource != REQUEST_RESOURCE:
+        continue
+
+      key = RequestKey(request_key)
+      if event.resource_uuid != key.id:
+        continue
+
+      snapshot: RequestSnapshot = event.snapshot()
+      snapshot.copy(destination)
+      resource = snapshot.find_resource()
+
+      if not resource:
+        print(f"Could not find request {key.id}", file=sys.stderr)
+      else:
+        destination_log.put(resource)
+        found = True
+
+      if not found:
+        print(f"No snapshot found for {key}", file=sys.stderr)
+
+def __copy_scenarios(scenario_keys: list, destination: str):
+  log = Log()
+
+  data_dir =  DataDir.instance(destination)
+  destination_log = Log(data_dir)
+
+  for scenario_key in scenario_keys:
+    found = False
+
+    for event in log.target_events:
+      if event.action != PUT_ACTION:
+        continue
+
+      if event.resource != SCENARIO_RESOURCE:
+        continue
+
+      key = ScenarioKey(scenario_key)
+      if event.resource_uuid != key.id:
+        continue
+
+      snapshot: ScenarioSnapshot = event.snapshot()
+      snapshot.copy(destination)
+      resource = snapshot.find_resource()
+
+      if not resource:
+        print(f"Could not find scenario {key.id}", file=sys.stderr)
+      else:
+        destination_log.put(resource)
+        found = True
+
+      if not found:
+        print(f"No snapshot found for {key}", file=sys.stderr)

stoobly_agent/app/models/adapters/python/response/mitmproxy_adapter.py

@@ -31,7 +31,7 @@ class MitmproxyResponseAdapter():
     if isinstance(status_code, int):
       return status_code
 
-    return decode(status_code)
+    return int(decode(status_code))
 
   @property
   def headers(self):

stoobly_agent/app/models/factories/resource/local_db/helpers/log.py

@@ -11,11 +11,13 @@ from .log_event import LogEvent
 from .snapshot_types import DELETE_ACTION, PUT_ACTION, Resource
 
 EVENT_DELIMITTER = "\n"
+LOG_ID = 'Log'
 
 class Log():
 
-  def __init__(self):
-    data_dir = DataDir.instance()
+  def __init__(self, data_dir: DataDir = None):
+    data_dir = data_dir or DataDir.instance()
+    
     self.__log_file_path = data_dir.snapshots_log_file_path
     self.__history_dir_path = data_dir.snapshots_history_dir_path
 
@@ -194,7 +196,7 @@ class Log():
       snapshot_exists = snapshot.exists
 
       if event.action == DELETE_ACTION or not snapshot_exists:
-        Logger.instance().info(f"{bcolors.OKBLUE}Removing {event.resource} {event.resource_uuid}{bcolors.ENDC}")
+        Logger.instance(LOG_ID).info(f"{bcolors.OKBLUE}Removing{bcolors.ENDC} {event.resource} {event.resource_uuid}")
 
         resource_events: List[LogEvent] = resource_index[event.resource_uuid]
         removed_events = {}
@@ -204,14 +206,14 @@ class Log():
           if event.uuid in removed_events:
             continue
 
-          Logger.instance().info(f"Removing event {event.uuid}")
+          Logger.instance(LOG_ID).info(f"Removing event {event.uuid}")
           self.remove_event_history(event, history_path, dry_run)
           removed_events[event.uuid] = True
 
         if event.action == DELETE_ACTION and snapshot_exists: 
           if not dry_run:
             snapshot.remove()
-          Logger.instance().info(f"Removing {event.resource} snapshot")
+          Logger.instance(LOG_ID).info(f"Removing {event.resource} snapshot")
 
   def build_raw_events(self, contents: str) -> List[str]:
     if not contents:
@@ -259,13 +261,13 @@ class Log():
       events = list(filter(lambda log_event: log_event.uuid != event.uuid, events))
 
     if len(events) == 0:
-      Logger.instance().info(f"Removing {history_path}")
+      Logger.instance(LOG_ID).info(f"Removing {history_path}")
 
       if not dry_run:
         os.remove(history_path)
     else:
       new_raw_events = list(map(lambda event: str(event), events))
-      Logger.instance().info(f"Updating {history_path}, Events: {len(raw_events)} -> {len(new_raw_events)}")
+      Logger.instance(LOG_ID).info(f"Updating {history_path}, Events: {len(raw_events)} -> {len(new_raw_events)}")
 
       if not dry_run:
         with open(history_path, 'w') as fp:

stoobly_agent/app/models/factories/resource/local_db/helpers/request_snapshot.py

@@ -1,4 +1,5 @@
 import os
+import shutil
 
 from stoobly_agent.app.models.adapters.orm import JoinedRequestStringAdapter
 from stoobly_agent.lib.orm.request import Request
@@ -47,6 +48,10 @@ class RequestSnapshot(Snapshot):
       with open(self.path, 'rb') as fp:
         self.__backup = fp.read()
 
+  def copy(self, dest_dir: str):
+    request_file_path = self.path
+    return self.copy_file(request_file_path, dest_dir)
+
   def find_resource(self):
     return Request.find_by(uuid=self.uuid)
 

stoobly_agent/app/models/factories/resource/local_db/helpers/scenario_snapshot.py

@@ -1,6 +1,7 @@
 import json
 import os
 import pdb
+import shutil
 
 from typing import Callable
 
@@ -74,6 +75,26 @@ class ScenarioSnapshot(Snapshot):
 
     self.iter_request_snapshots(self.__handle_backup_requests)
 
+  def copy(self, destination):
+    self.copy_metadata(destination)
+    self.copy_requests(destination)
+  
+  def copy_metadata(self, dest_dir: str):
+    metadata_file_path = self.metadata_path
+    return self.copy_file(metadata_file_path, dest_dir)
+
+  def copy_requests(self, dest_dir: str):
+    if not os.path.exists(dest_dir):
+      os.makedirs(dest_dir, exist_ok=True)
+
+    requests_file_path = self.requests_path
+
+    if os.path.exists(requests_file_path):
+      # A request only ever belongs to one scenario
+      self.iter_request_snapshots(lambda snapshot: self.__handle_copy_requests(snapshot, dest_dir))
+
+      self.copy_file(requests_file_path, dest_dir)
+
   def iter_request_snapshots(self, handler: Callable[[RequestSnapshot], None]):
     requests_file_path = self.requests_path
 
@@ -136,5 +157,8 @@ class ScenarioSnapshot(Snapshot):
   def __handle_backup_requests(self, request_snapshot: RequestSnapshot):
     self.__requests_backup[request_snapshot.uuid] = request_snapshot.request
 
+  def __handle_copy_requests(self, request_snapshot: RequestSnapshot, dest_dir: str):
+    request_snapshot.copy(dest_dir)
+
   def __handle_remove_requests(self, request_snapshot: RequestSnapshot):
     request_snapshot.remove()

stoobly_agent/app/models/factories/resource/local_db/helpers/snapshot.py

@@ -1,4 +1,5 @@
-from typing import TypedDict
+import os
+import shutil
 
 from stoobly_agent.config.data_dir import DataDir
 
@@ -14,4 +15,19 @@ class Snapshot():
 
   @property
   def data_dir(self):
-    return self.__data_dir
+    return self.__data_dir
+
+  def copy_file(self, src: str, dest_dir: str):
+    if not os.path.exists(src):
+      return None
+
+    data_dir_parent = os.path.dirname(self.data_dir.path)
+    dest_file_path = src.replace(data_dir_parent, dest_dir)
+    dest_dir_path = os.path.dirname(dest_file_path)
+
+    if not os.path.exists(dest_dir_path):
+      os.makedirs(dest_dir_path, exist_ok=True)
+
+    shutil.copy(src, dest_file_path)
+
+    return dest_file_path

stoobly_agent/app/models/factories/resource/local_db/helpers/tiebreak_scenario_request.py

@@ -5,6 +5,8 @@ from typing import List
 from stoobly_agent.lib.cache import Cache
 from stoobly_agent.lib.orm.request import Request
 
+PREFIX = 'last_request_id'
+
 def access_request(session_id: str, request_id: int, timeout = None):
   cache = Cache.instance()
   _last_request_id_key = __last_request_id_key(session_id)
@@ -18,6 +20,9 @@ def generate_session_id(query: dict):
 
   return hashlib.md5(b'.'.join(toks)).hexdigest()
 
+def reset():
+  Cache.instance().clear(f".+\.{PREFIX}")
+
 def tiebreak_scenario_request(session_id: str, requests: List[Request]):
   if len(requests) == 0:
     return None
@@ -43,4 +48,4 @@ def tiebreak_scenario_request(session_id: str, requests: List[Request]):
 
 def __last_request_id_key(_key = None):
   _key = _key or generate_session_id()
-  return f"{_key}.last_request_id"
+  return f"{_key}.{PREFIX}"

stoobly_agent/app/models/factories/resource/local_db/query_param_adapter.py

@@ -58,12 +58,16 @@ class LocalDBQueryParamAdapter(LocalDBAdapter):
     if not name in _query_params:
       _query_params[name] = []
 
-    try:
-      index = _query_params[name].index(decoded_id['value'])
-    except ValueError as e:
-      return self.not_found()
+    if isinstance(_query_params[name], list):
+      try:
+        index = _query_params[name].index(decoded_id['value'])
+      except ValueError as e:
+        return self.not_found()
+
+      _query_params[name][index] = value
+    else:
+      _query_params[name] = value
 
-    _query_params[name][index] = value
     parsed_url = parsed_url._replace(query=urlencode(_query_params, True))
 
     request = LocalDBRequestAdapter(self.__request_orm).update(request_id, url=parsed_url.geturl())

stoobly_agent/app/models/factories/resource/local_db/request_adapter.py

@@ -112,6 +112,7 @@ class LocalDBRequestAdapter(LocalDBAdapter):
 
     headers = {}
     headers[custom_headers.MOCK_REQUEST_ID] = str(request.id)
+    headers[custom_headers.MOCK_REQUEST_KEY] = request.key()
     headers[custom_headers.RESPONSE_LATENCY] = str(request.latency)
 
     return (

stoobly_agent/app/proxy/handle_mock_service.py

@@ -10,7 +10,7 @@ from stoobly_agent.app.models.request_model import RequestModel
 from stoobly_agent.app.proxy.mitmproxy.request_facade import MitmproxyRequestFacade
 from stoobly_agent.app.proxy.utils.rewrite_rules_to_ignored_components_service import rewrite_rules_to_ignored_components
 from stoobly_agent.config.constants import custom_headers, env_vars, lifecycle_hooks, mock_policy, request_origin
-from stoobly_agent.lib.logger import Logger
+from stoobly_agent.lib.logger import bcolors, Logger
 
 from .constants import custom_response_codes
 from .mock.context import MockContext
@@ -20,7 +20,7 @@ from .utils.allowed_request_service import get_active_mode_policy
 from .utils.request_handler import reverse_proxy
 from .utils.response_handler import bad_request, pass_on
 
-LOG_ID = 'HandleMock'
+LOG_ID = 'Mock'
 
 class MockOptions(TypedDict):
     failure: Callable
@@ -124,11 +124,18 @@ def handle_request_mock(context: MockContext):
         success=lambda context: __handle_mock_success(context)
     )
 
-def __handle_mock_success(context: MockContext) -> None:
-    response = context.response
-    start_time = context.start_time
+def handle_response_mock(context: MockContext):
+    response = context.flow.response
+    request_key = response.headers.get(custom_headers.MOCK_REQUEST_KEY)
+
+    if request_key:
+        request = context.flow.request
+        Logger.instance(LOG_ID).info(f"{bcolors.OKCYAN}Mocked{bcolors.ENDC} {request.url} -> {request_key}")
 
+def __handle_mock_success(context: MockContext) -> None:
     if os.environ.get(env_vars.AGENT_SIMULATE_LATENCY):
+        response = context.response
+        start_time = context.start_time
         __simulate_latency(response.headers.get(custom_headers.RESPONSE_LATENCY), start_time)
 
 def __handle_mock_failure(context: MockContext) -> None:
@@ -143,7 +150,7 @@ def __handle_mock_failure(context: MockContext) -> None:
     else:
         req.headers[custom_headers.REQUEST_ORIGIN] = request_origin.PROXY
 
-    Logger.instance().debug(f"{LOG_ID}:ReverseProxy:UpstreamUrl: {upstream_url}")
+    Logger.instance(LOG_ID).debug(f"UpstreamUrl: {upstream_url}")
 
     reverse_proxy(req, upstream_url, {})
 
@@ -167,9 +174,9 @@ def __simulate_latency(expected_latency: str, start_time: float) -> float:
 
     wait_time = expected_latency - estimated_rtt_network_latency - api_latency
 
-    Logger.instance().debug(f"{LOG_ID}:Expected latency: {expected_latency}")
-    Logger.instance().debug(f"{LOG_ID}:API latency: {api_latency}")
-    Logger.instance().debug(f"{LOG_ID}:Wait time: {wait_time}")
+    Logger.instance(LOG_ID).debug(f"Expected latency: {expected_latency}")
+    Logger.instance(LOG_ID).debug(f"API latency: {api_latency}")
+    Logger.instance(LOG_ID).debug(f"Wait time: {wait_time}")
 
     if wait_time > 0:
         time.sleep(wait_time)

stoobly_agent/app/proxy/handle_record_service.py

@@ -19,7 +19,7 @@ from .record.upload_request_service import inject_upload_request
 from .utils.allowed_request_service import get_active_mode_policy
 from .utils.response_handler import bad_request, disable_transfer_encoding 
 
-LOG_ID = 'HandleRecord'
+LOG_ID = 'Record'
 
 def handle_response_record(context: RecordContext):
     flow = context.flow
@@ -32,7 +32,7 @@ def handle_response_record(context: RecordContext):
     request_model = RequestModel(intercept_settings.settings)
 
     active_record_policy = get_active_mode_policy(request, intercept_settings)
-    Logger.instance().debug(f"{LOG_ID}:RecordPolicy: {active_record_policy}")
+    Logger.instance(LOG_ID).debug(f"RecordPolicy: {active_record_policy}")
 
     if active_record_policy == record_policy.ALL:
         __record_request(context, request_model)

stoobly_agent/app/proxy/intercept_handler.py

@@ -5,7 +5,7 @@ from mitmproxy.http import HTTPFlow as MitmproxyHTTPFlow
 from mitmproxy.http import Headers, Request as MitmproxyRequest
 
 from stoobly_agent.app.proxy.context import InterceptContext
-from stoobly_agent.app.proxy.handle_mock_service import handle_request_mock
+from stoobly_agent.app.proxy.handle_mock_service import handle_request_mock, handle_response_mock
 from stoobly_agent.app.proxy.handle_replay_service import handle_request_replay, handle_response_replay
 from stoobly_agent.app.proxy.handle_record_service import handle_response_record
 from stoobly_agent.app.proxy.handle_test_service import handle_request_test, handle_response_test
@@ -21,7 +21,7 @@ from stoobly_agent.lib.logger import Logger
 # Disable proxy settings in urllib
 os.environ['no_proxy'] = '*'
 
-LOG_ID = 'InterceptHandler'
+LOG_ID = 'Intercept'
 
 def request(flow: MitmproxyHTTPFlow):
     request: MitmproxyRequest = flow.request
@@ -36,7 +36,7 @@ def request(flow: MitmproxyHTTPFlow):
     __intercept_hook(lifecycle_hooks.BEFORE_REQUEST, flow, intercept_settings)
 
     active_mode = intercept_settings.mode
-    Logger.instance().debug(f"{LOG_ID}:ProxyMode: {active_mode}")
+    Logger.instance(LOG_ID).debug(f"ProxyMode: {active_mode}")
 
     if active_mode == mode.MOCK:
         context = MockContext(flow, intercept_settings)
@@ -69,7 +69,10 @@ def response(flow: MitmproxyHTTPFlow):
 
     active_mode = intercept_settings.mode
 
-    if active_mode == mode.RECORD:
+    if active_mode == mode.MOCK:
+        context = MockContext(flow, intercept_settings)
+        return handle_response_mock(context)
+    elif active_mode == mode.RECORD:
         context = RecordContext(flow, intercept_settings)
         return handle_response_record(context)
     elif active_mode == mode.REPLAY:

stoobly_agent/app/proxy/mitmproxy/request_facade.py

@@ -17,6 +17,8 @@ from stoobly_agent.lib.utils.decode import decode
 from .request_body_facade import MitmproxyRequestBodyFacade
 from .request import Request
 
+LOG_ID = 'Request'
+
 class MitmproxyRequestFacade(Request):
 
     ###
@@ -137,7 +139,7 @@ class MitmproxyRequestFacade(Request):
 
         if len(rewrites):
             self.__rewrite_url(rewrites)
-            Logger.instance().debug(f"{bcolors.OKBLUE} Rewritten URL{bcolors.ENDC} {self.url}")
+            Logger.instance(LOG_ID).debug(f"{bcolors.OKBLUE} Rewritten URL{bcolors.ENDC} {self.url}")
 
     # Find all the rules that match request url and method
     def select_rewrite_rules(self, rules: List[RewriteRule]) -> List[RewriteRule]:
@@ -186,7 +188,7 @@ class MitmproxyRequestFacade(Request):
             })
 
     def __rewrite_handler(self, rewrite: ParameterRule) -> str:
-        Logger.instance().info(f"{bcolors.OKCYAN}Rewriting {rewrite.type.lower()}{bcolors.ENDC} {rewrite.name} => {rewrite.value}")
+        Logger.instance(LOG_ID).info(f"{bcolors.OKCYAN}Rewriting{bcolors.ENDC} {rewrite.type.lower()} {rewrite.name} => {rewrite.value}")
         return rewrite.value
 
     def __rewrite_url(self, rewrites: List[UrlRule]):

stoobly_agent/app/proxy/mock/eval_fixtures_service.py

@@ -11,6 +11,8 @@ from stoobly_agent.lib.logger import bcolors, Logger
 
 from .types import Fixtures
 
+LOG_ID = 'Fixture'
+
 class Options():
   public_directory_path: str
   response_fixtures: Fixtures
@@ -44,7 +46,7 @@ def eval_fixtures(request: MitmproxyRequest, **options: Options) -> Union[Respon
     response.raw = BytesIO(fp.read()) 
     response.headers = headers
 
-    Logger.instance().debug(f"{bcolors.OKBLUE}Resolved fixture {fixture_path}{bcolors.ENDC}")
+    Logger.instance(LOG_ID).debug(f"{bcolors.OKBLUE}Resolved{bcolors.ENDC} fixture {fixture_path}")
 
     return response
 

stoobly_agent/app/proxy/mock/hashed_request_decorator.py

@@ -17,9 +17,9 @@ COMPONENT_TYPES = {
     'RESPONSE': 5
 }
 
-class HashedRequestDecorator:
+LOG_ID = 'HashedRequest'
 
-    LOG_ID = 'lib.hashed_request_decorator'
+class HashedRequestDecorator:
 
     def __init__(self, request: MitmproxyRequestFacade):
         self.request = request
@@ -53,8 +53,8 @@ class HashedRequestDecorator:
 
         ignored_headers = {} if with_ignored else self.ignored_headers
 
-        Logger.instance().debug(f"{bcolors.OKCYAN}Hashing headers...{bcolors.ENDC}")
-        Logger.instance().debug(f"{bcolors.OKBLUE}Ignoring{bcolors.ENDC} {ignored_headers}")
+        Logger.instance(LOG_ID).debug(f"{bcolors.OKCYAN}Hashing headers...{bcolors.ENDC}")
+        Logger.instance(LOG_ID).debug(f"{bcolors.OKBLUE}Ignoring{bcolors.ENDC} {ignored_headers}")
         serialized_params = self.__serialize_params(headers, ignored_headers)
 
         return self.__hash_serialized_params(serialized_params)
@@ -68,8 +68,8 @@ class HashedRequestDecorator:
         params = self.__deflatten_multi_dict(query_params)
         ignored_params = {} if with_ignored else self.ignored_query_params
 
-        Logger.instance().debug(f"{bcolors.OKCYAN}Hashing query params...{bcolors.ENDC}")
-        Logger.instance().debug(f"{bcolors.OKBLUE}Ignoring{bcolors.ENDC} {ignored_params}")
+        Logger.instance(LOG_ID).debug(f"{bcolors.OKCYAN}Hashing query params...{bcolors.ENDC}")
+        Logger.instance(LOG_ID).debug(f"{bcolors.OKBLUE}Ignoring{bcolors.ENDC} {ignored_params}")
         serialized_params = self.__serialize_params(params, ignored_params)
 
         return self.__hash_serialized_params(serialized_params)
@@ -81,8 +81,8 @@ class HashedRequestDecorator:
         params = self.request.parsed_body
         ignored_params = {} if with_ignored else self.ignored_body_params
 
-        Logger.instance().debug(f"{bcolors.OKCYAN}Hashing body params...{bcolors.ENDC}")
-        Logger.instance().debug(f"{bcolors.OKBLUE}Ignoring{bcolors.ENDC} {ignored_params}")
+        Logger.instance(LOG_ID).debug(f"{bcolors.OKCYAN}Hashing body params...{bcolors.ENDC}")
+        Logger.instance(LOG_ID).debug(f"{bcolors.OKBLUE}Ignoring{bcolors.ENDC} {ignored_params}")
 
         return RequestHasher.instance().hash_params(params, ignored_params)
 
@@ -120,13 +120,13 @@ class HashedRequestDecorator:
                 for param in value:
                     param_hash = hashlib.md5(self.__serialize_param(key, param)).hexdigest()
 
-                    Logger.instance().debug(f"{self.LOG_ID}.serialized_query_params_hash:{key} -> {param} ({param_hash})")
+                    Logger.instance(LOG_ID).debug(f"Serializing {key} -> {param} ({param_hash})")
 
                     serialized_params.append(param_hash)
             else:
                 param_hash = hashlib.md5(self.__serialize_param(key, value)).hexdigest()
 
-                Logger.instance().debug(f"{self.LOG_ID}.serialized_query_params_hash:{key} -> {value} ({param_hash})")
+                Logger.instance(LOG_ID).debug(f"Serializing {key} -> {value} ({param_hash})")
 
                 serialized_params.append(param_hash)