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

stoobly_agent/app/proxy/mock/request_hasher.py

@@ -8,6 +8,8 @@ from typing import List, Dict, TypedDict, Union
 from stoobly_agent.lib.logger import Logger, bcolors
 from stoobly_agent.lib.utils.python_to_ruby_type import type_map
 
+LOG_ID = 'RequestHasher'
+
 class IgnoredParam(TypedDict):
   inferred_type: str
   query: str
@@ -107,7 +109,7 @@ class RequestHasher():
     return self.type_map.get(str(val.__class__))
 
   def __serialize_param(self, query, key: str, val):
-    Logger.instance().debug(f"{bcolors.OKBLUE}Serializing{bcolors.ENDC} {query} => {val}")
+    Logger.instance(LOG_ID).debug(f"{bcolors.OKBLUE}Serializing{bcolors.ENDC} {query} -> {val}")
 
     if isinstance(val, bool):
       # Ruby boolean are lower case

stoobly_agent/app/proxy/record/upload_request_service.py

@@ -23,7 +23,7 @@ AGENT_STATUSES = {
     'REQUESTS_MODIFIED': 'requests-modified'
 }
 
-LOG_ID = 'UploadRequest'
+LOG_ID = 'Record'
 NAMESPACE_FOLDER = 'stoobly'
 
 def inject_upload_request(request_model: RequestModel, intercept_settings: InterceptSettings):
@@ -48,7 +48,7 @@ def inject_upload_request(request_model: RequestModel, intercept_settings: Inter
 def upload_request(
     request_model: RequestModel, intercept_settings: InterceptSettings, flow: MitmproxyHTTPFlow = None
 ):
-    Logger.instance().info(f"{bcolors.OKCYAN}Uploading{bcolors.ENDC} {flow.request.url}")
+    Logger.instance(LOG_ID).info(f"{bcolors.OKCYAN}Recording{bcolors.ENDC} {flow.request.url}")
 
     joined_request = join_rewritten_request(flow, intercept_settings)
 
@@ -68,17 +68,17 @@ def upload_request(
  
     if intercept_settings.settings.is_debug():
         file_path = __debug_request(flow.request, joined_request.build())
-        Logger.instance().debug(f"{LOG_ID}: Writing request to {file_path}")
+        Logger.instance(LOG_ID).debug(f"Writing request to {file_path}")
     elif not res:
         file_path = __debug_request(flow.request, joined_request.build())
-        Logger.instance().error(f"Error: Failed to upload, writing request to {file_path}")
+        Logger.instance(LOG_ID).error(f"Error: Failed to upload, writing request to {file_path}")
 
     return res
 
 def upload_staged_request(
     request: Request, request_model: RequestModel, project_key: str, scenario_key: str = None
 ):
-    Logger.instance().info(f"{bcolors.OKCYAN}Uploading{bcolors.ENDC} {request.url}")
+    Logger.instance(LOG_ID).info(f"{bcolors.OKCYAN}Recording{bcolors.ENDC} {request.url}")
 
     response = request.response
 

stoobly_agent/app/proxy/replay/alias_resolver.py

@@ -6,6 +6,8 @@ from stoobly_agent.lib.logger import Logger, bcolors
 from stoobly_agent.lib.orm.trace import Trace
 from stoobly_agent.lib.orm.trace_alias import TraceAlias
 
+LOG_ID = 'Alias'
+
 class AliasResolver():
 
   def __init__(self, trace: Trace, strategy: alias_resolve_strategy.AliasResolveStrategy):
@@ -28,7 +30,7 @@ class AliasResolver():
       trace_alias.assigned_to = value
       trace_alias.save()
 
-      Logger.instance().info(f"{bcolors.OKBLUE}ASSIGN alias {trace_alias.name}: {value} -> {trace_alias.value}{bcolors.ENDC}")
+      Logger.instance(LOG_ID).info(f"{bcolors.OKBLUE}Assigned{bcolors.ENDC} {trace_alias.name}: {value} -> {trace_alias.value}")
 
   def resolve_alias(self, alias_name: str, value: str):
     trace_alias = self.__resolve_alias(alias_name, value)
@@ -51,7 +53,7 @@ class AliasResolver():
     })
 
     if trace_alias:
-      Logger.instance().info(f"{bcolors.OKGREEN}CREATE alias {trace_alias.name}: {value}{bcolors.ENDC}")
+      Logger.instance(LOG_ID).info(f"{bcolors.OKGREEN}Created{bcolors.ENDC} alias {trace_alias.name}: {value}")
 
     return trace_alias
 
@@ -114,4 +116,4 @@ class AliasResolver():
     return str(value) if isinstance(value, list) or isinstance(value, dict) else value
 
   def __log_resolved_aliases(self, trace_aliases):
-    trace_aliases.each(lambda trace_alias: Logger.instance().debug(f"\tResolved Trace Alias: {trace_alias.to_dict()}"))
+    trace_aliases.each(lambda trace_alias: Logger.instance(LOG_ID).debug(f"\tResolved Trace Alias: {trace_alias.to_dict()}"))

stoobly_agent/app/proxy/replay/body_parser_service.py

@@ -73,12 +73,8 @@ def parse_multipart_form_data(content, content_type) -> Dict[bytes, bytes]:
 
     if not decoded_multipart:
         return content
-
-    params_array = []
-    for ele in decoded_multipart:
-        params_array.append((decode(ele[0]), ele[1]))
  
-    return MultiDict(params_array)
+    return MultiDict(decoded_multipart)
 
 def parse_www_form_urlencoded(content):
     try:

stoobly_agent/app/proxy/replay/multipart.py

@@ -1,7 +1,9 @@
+import io
 import mimetypes
 import re
 import pdb
 
+from multipart import MultipartParser
 from urllib.parse import quote
 
 from mitmproxy.net.http import headers
@@ -64,31 +66,11 @@ def decode(hdrs, content):
     except (KeyError, UnicodeError):
         return
 
-    boundary_parts = content.split(b"--" + boundary)
-    if len(boundary_parts) == 0:
-        return
-
-    rx = re.compile(br'\bname="([^"]+)"')
     r = []
-    for i in boundary_parts:
-        parts = i.splitlines(True)
-
-        if len(parts) > 1 and parts[0][0:2] != b"--":
-            match = rx.search(parts[1])
-            if match:
-                key = match.group(1)
-
-                # Continue parsing until we see just a line with CRLF
-                ar = parts[2:]
-                for i, ele in enumerate(ar):
-                    if ele == CRLF:
-                        value = b"".join(parts[3 + i:])
-
-                        # Remove CRLF preceding the next boundary
-                        length = len(value)
-                        if value[length - 2:] == CRLF:
-                            value = value[0:length - 2]
-
-                        r.append((key, value))
-                        break
-    return r
+    parser = MultipartParser(io.BytesIO(content), boundary=boundary)
+    for part in parser.parts():
+        if part.content_type.lower() == 'application/octet-stream':
+            r.append((part.name, part.raw))
+        else:
+            r.append((part.name, part.value))
+    return r

stoobly_agent/app/proxy/replay/trace_context.py

@@ -21,6 +21,7 @@ from stoobly_agent.lib.orm.trace_request import TraceRequest
 from stoobly_agent.lib.utils import jmespath
 
 AliasMap = Dict[str, RequestComponentName]
+LOG_ID = 'Trace'
 
 class TraceContext:
 
@@ -32,7 +33,7 @@ class TraceContext:
     self.__requests: List[Request] = []
     self.__remote_project_key: ProjectKey = None
 
-    Logger.instance().debug(f"Using trace {self.__trace.id}")
+    Logger.instance(LOG_ID).debug(f"Using trace {self.__trace.id}")
 
   @property
   def alias_resolve_strategy(self):
@@ -71,7 +72,7 @@ class TraceContext:
       )
 
     if endpoint:
-      Logger.instance().debug(f"\tMatched Endpoint: {endpoint}")
+      Logger.instance(LOG_ID).debug(f"\tMatched Endpoint: {endpoint}")
 
       if self.alias_resolve_strategy != alias_resolve_strategy.NONE:
         self.rewrite_request(request, endpoint)
@@ -133,7 +134,7 @@ class TraceContext:
     request.path = '/' + '/'.join(path_segment_strings)
 
   def __rewrite_handler(self, component_type: str, alias_name: str, name: str, value):
-    Logger.instance().info(f"{bcolors.OKCYAN}REWRITE {component_type} alias {alias_name}{bcolors.ENDC} {name} => {value}")
+    Logger.instance(LOG_ID).info(f"{bcolors.OKCYAN}Rewriting{bcolors.ENDC} {component_type} alias {alias_name} {name} => {value}")
 
   def __rewrite_headers(
     self, request: Request, header_names: List[RequestComponentName], id_to_alias: AliasMap
@@ -217,7 +218,7 @@ class TraceContext:
     '''
     content = decode_response(response.content, response.headers.get('content-type'))
     if not is_traversable(content):
-        return Logger.instance().debug('Skipping creating aliases, content is not traversable')
+        return Logger.instance(LOG_ID).debug('Skipping creating aliases, content is not traversable')
 
     id_to_alias = {}
     aliases = endpoint['aliases']
@@ -225,18 +226,18 @@ class TraceContext:
       id_to_alias[_alias['id']] = _alias
 
     response_param_names = endpoint['response_param_names']
-    Logger.instance().debug(f"\tBuilding Trace Aliases from: {response_param_names}")
+    Logger.instance(LOG_ID).debug(f"\tBuilding Trace Aliases from: {response_param_names}")
 
     for response_param_name in response_param_names:
       try:
         values = self.__query_resolves_response(response_param_name, content)
-        Logger.instance().debug(f"\tValues: {values}")
+        Logger.instance(LOG_ID).debug(f"\tValues: {values}")
       except Exception as e:
-        Logger.instance().error(e)
+        Logger.instance(LOG_ID).error(e)
         continue
 
       _alias: Alias = id_to_alias[response_param_name['alias_id']]
-      Logger.instance().debug(f"\tAlias: {_alias}")
+      Logger.instance(LOG_ID).debug(f"\tAlias: {_alias}")
 
       for value in values:  
         if _alias and value:
@@ -292,4 +293,4 @@ class TraceContext:
         'value': _alias.value,
       })
 
-    tabulate_print(data, print_handler=Logger.instance().debug)
+    tabulate_print(data, print_handler=Logger.instance(LOG_ID).debug)

stoobly_agent/app/proxy/test/helpers/upload_test_service.py

@@ -13,6 +13,8 @@ from stoobly_agent.app.proxy.intercept_settings import InterceptSettings
 from ...intercept_settings import InterceptSettings
 from ...record.join_request_service import join_rewritten_request
 
+LOG_ID = 'Test'
+
 class UploadTestData(TypedDict):
   expected_response: str
   log: str
@@ -31,7 +33,7 @@ def inject_upload_test(
     api = TestsResource(settings.remote.api_url, settings.remote.api_key)
 
   if not intercept_settings:
-    intercept_settings = InterceptSettings(Settings.instance())
+    intercept_settings = InterceptSettings(Settings.instance(LOG_ID))
 
   return lambda flow, **kwargs: upload_test(api, intercept_settings, flow, **kwargs)
 
@@ -43,14 +45,14 @@ def upload_test(
 ) -> Response:
     joined_request = join_rewritten_request(flow, intercept_settings)
 
-    Logger.instance().info(f"{bcolors.OKCYAN}Uploading{bcolors.ENDC} test results for {joined_request.proxy_request.url()}")
+    Logger.instance(LOG_ID).info(f"{bcolors.OKCYAN}Uploading{bcolors.ENDC} test results for {joined_request.proxy_request.url()}")
 
     raw_requests = joined_request.build()
 
     # If report key is set, upload test to report
     report_key = intercept_settings.report_key
     if report_key:
-      Logger.instance().debug(f"Using report {report_key}")
+      Logger.instance(LOG_ID).debug(f"Using report {report_key}")
 
       api.with_report_key(report_key, kwargs)
 

stoobly_agent/app/proxy/utils/allowed_request_service.py

@@ -9,6 +9,8 @@ from stoobly_agent.app.settings.firewall_rule import FirewallRule
 from stoobly_agent.config.constants import mock_policy, request_origin
 from stoobly_agent.lib.logger import bcolors, Logger
 
+LOG_ID = 'Firewall'
+
 def get_active_mode_policy(request: MitmproxyRequest, intercept_settings: InterceptSettings):
     if intercept_settings.request_origin == request_origin.CLI:
         return intercept_settings.policy 
@@ -39,7 +41,7 @@ def __request_excluded(request: MitmproxyRequest, exclude_rules: List[FirewallRu
         rules = list(filter(lambda rule: method in rule.methods, exclude_rules))
         patterns = list(map(lambda rule: rule.pattern, rules))
         if __exclude(request, patterns):
-            Logger.instance().info(f"{bcolors.OKBLUE}{request.method} {request.url} excluded by firewall rule{bcolors.ENDC}")
+            Logger.instance(LOG_ID).info(f"{bcolors.OKBLUE}Excluding{bcolors.ENDC} {request.method} {request.url}")
             return True
     
     return False
@@ -54,12 +56,12 @@ def __request_included(request: MitmproxyRequest, include_rules: List[FirewallRu
     # If there are include rules, but none that match the request's method,
     # then we know that none of the include rules will match the request
     if len(include_rules) > 0 and len(rules) == 0:
-        Logger.instance().info(f"{bcolors.OKBLUE}{request.method} {request.url} not included by firewall rule{bcolors.ENDC}")
+        Logger.instance(LOG_ID).info(f"{bcolors.OKBLUE}Not Including{bcolors.ENDC} {request.method} {request.url}")
         return False
 
     patterns = list(map(lambda rule: rule.pattern, rules))
     if not __include(request, patterns):
-        Logger.instance().info(f"{bcolors.OKBLUE}{request.method} {request.url} not included by firewall rule{bcolors.ENDC}")
+        Logger.instance(LOG_ID).info(f"{bcolors.OKBLUE}Not Including{bcolors.ENDC} {request.method} {request.url}")
         return False
 
     return True
@@ -80,7 +82,7 @@ def __include(request: MitmproxyRequest, patterns: List[str]) -> bool:
             if re.match(pattern, request.url):
                 return True
         except re.error as e:
-            Logger.instance().error(f"RegExp error '{e}' for {pattern}")
+            Logger.instance(LOG_ID).error(f"RegExp error '{e}' for {pattern}")
             return False
 
     return False
@@ -94,7 +96,7 @@ def __exclude(request: MitmproxyRequest, patterns: List[str]) -> bool:
             if re.match(pattern, request.url):
                 return True
         except re.error as e:
-            Logger.instance().error(f"RegExp error '{e}' for {pattern}")
+            Logger.instance(LOG_ID).error(f"RegExp error '{e}' for {pattern}")
             return True
 
     return False

stoobly_agent/app/proxy/utils/request_handler.py

@@ -6,8 +6,10 @@ from urllib.parse import urlparse
 from stoobly_agent.lib.logger import Logger
 from stoobly_agent.lib.orm.utils.requests_response_builder import RequestsResponseBuilder
 
+LOG_ID = 'ReversePorxy'
+
 def reverse_proxy(request: MitmproxyRequest, service_url: str, options = {}):
-    Logger.instance().debug(f"ReverseProxy:ServiceUrl: {service_url}")
+    Logger.instance(LOG_ID).debug(service_url)
 
     uri = urlparse(service_url)
 

stoobly_agent/app/settings/__init__.py

@@ -18,10 +18,12 @@ from .proxy_settings import ProxySettings
 from .remote_settings import RemoteSettings
 from .ui_settings import UISettings
 
+LOG_ID = 'Settings'
+
 class Settings:
-    LOG_ID = 'app.settings'
+    _instances = None
 
-    __instance = None
+    __data_dir: DataDir = None
 
     __cli_settings = None
     __proxy_settings = None
@@ -34,10 +36,11 @@ class Settings:
     __load_lock = False
     __watching = False
 
-    def __init__(self):
-        if Settings.__instance:
+    def __init__(self, data_dir_path: str = None):
+        if Settings._instances.get(data_dir_path):
             raise RuntimeError('Call instance() instead')
 
+        self.__data_dir = DataDir.instance(data_dir_path)
         self.__detect_paths()
 
         # If the config does not exist, use template
@@ -47,11 +50,26 @@ class Settings:
         self.__load_settings()
 
     @classmethod
-    def instance(cls):
-        if cls.__instance is None:
-            cls.__instance = cls()
+    def instance(cls, data_dir_path: str = None):
+        if not cls._instances:
+            cls._instances = {}
+
+        if not cls._instances.get(data_dir_path):
+            cls._instances[data_dir_path] = cls(data_dir_path)
 
-        return cls.__instance
+        return cls._instances[data_dir_path]
+
+    @classmethod
+    def handle_chdir(cls):
+        '''
+        Reloads data dir to be relative to new working directory
+        '''
+        DataDir.handle_chdir()
+
+        if cls._instances and None in cls._instances:
+            del cls._instances[None]
+
+        return cls.instance()
 
     ### Statuses
 
@@ -62,7 +80,7 @@ class Settings:
 
     @property
     def cli(self):
-        return self.__cli_settings 
+        return self.__cli_settings
 
     @property
     def ui(self):
@@ -107,8 +125,8 @@ class Settings:
         if not self.__settings:
             self.__load_settings()
 
-        return { 
-            **self.__settings, 
+        return {
+            **self.__settings,
             **{ 'cli': self.__cli_settings.to_dict() },
             **{ 'proxy': self.__proxy_settings.to_dict() },
             **{ 'remote': self.__remote_settings.to_dict() },
@@ -165,7 +183,7 @@ class Settings:
         copyfile(SourceDir.instance().settings_template_file_path, self.__settings_file_path)
 
     def __detect_paths(self):
-        self.__settings_file_path = os.environ.get(env_vars.AGENT_CONFIG_PATH) or DataDir.instance().settings_file_path
+        self.__settings_file_path = os.environ.get(env_vars.AGENT_CONFIG_PATH) or self.__data_dir.settings_file_path
         self.__schema_file_path = SourceDir.instance().schema_file_path
 
     def __load_settings(self):
@@ -179,14 +197,14 @@ class Settings:
                 self.from_dict(settings)
             except yaml.YAMLError as exc:
                 Logger.instance().error(exc)
-        
+
     def __reload_settings(self, event):
         if not self.__load_lock:
             from stoobly_agent.app.proxy.utils.publish_change_service import publish_change
 
             self.__load_lock = True
 
-            Logger.instance().debug(f"{self.LOG_ID}.reload_settings")
+            Logger.instance(LOG_ID).debug('Reloading settings')
             self.__load_settings()
 
             publish_change(statuses.SETTINGS_MODIFIED, self.__settings, sync=True)

stoobly_agent/cli.py

@@ -88,7 +88,7 @@ def init(**kwargs):
 ''')
 @click.option('--confdir', default=os.path.join(os.path.expanduser('~'), '.mitmproxy'), help='Location of the default mitmproxy configuration files.')
 @click.option('--connection-strategy', help=', '.join(CONNECTION_STRATEGIES), type=click.Choice(CONNECTION_STRATEGIES))
-@click.option('--flow-detail', default='1', type=click.Choice(['1', '2', '3', '4']), help='''
+@click.option('--flow-detail', default='1', type=click.Choice(['0', '1', '2', '3', '4']), help='''
   The display detail level for flows in mitmdump: 0 (quiet) to 4 (very verbose).
   0: no output
   1: shortened request URL with response status code

stoobly_agent/config/constants/custom_headers.py

@@ -5,6 +5,7 @@ REMOTE_PROJECT_KEY = 'X-Stoobly-Endpoints-Project-Id'
 MOCK_POLICY = 'X-Mock-Policy'
 MOCK_REQUEST_ID = 'X-Stoobly-Request-Id'
 MOCK_REQUEST_ENDPOINT_ID = 'X-Stoobly-Request-Endpoint-Id'
+MOCK_REQUEST_KEY = 'X-Stoobly-Request-Key'
 DO_PROXY = 'X-Do-Proxy'
 LIFECYCLE_HOOKS_PATH = 'X-Stoobly-Lifecycle-Hooks-Path'
 PROJECT_KEY = 'X-Project-Key'

stoobly_agent/config/data_dir.py

@@ -8,34 +8,47 @@ class DataDir:
     DB_FILE_NAME = 'stoobly_agent.sqlite3'
     DB_VERSION_NAME = 'VERSION'
 
-    _instance = None
+    _instances = None
 
-    def __init__(self):
-        if DataDir._instance:
+    def __init__(self, path: str = None):
+        if DataDir._instances.get(path):
             raise RuntimeError('Call instance() instead')
         else:
-            cwd = os.getcwd()
-            self.__data_dir_path = os.path.join(cwd, self.DATA_DIR_NAME)
+            if path:
+                self.__data_dir_path = os.path.join(path, self.DATA_DIR_NAME)
+            else:
+                cwd = os.getcwd()
+                self.__data_dir_path = os.path.join(cwd, self.DATA_DIR_NAME)
+
+                # If the current working directory does not contain a .stoobly folder,
+                # then search in the parent directories until the home directory.
+                if not os.path.exists(self.__data_dir_path):
+                    data_dir = self.find_data_dir(cwd)
+
+                    if not data_dir:
+                        self.__data_dir_path = os.path.join(os.path.expanduser('~'), self.DATA_DIR_NAME)
+                    else:
+                        self.__data_dir_path = data_dir
 
-            # If the current working directory does not contain a .stoobly folder,
-            # then search in the parent directories until the home directory.
             if not os.path.exists(self.__data_dir_path):
-                data_dir = self.find_data_dir(cwd)
+                os.makedirs(self.__data_dir_path, exist_ok=True)
 
-                if not data_dir:
-                    self.__data_dir_path = os.path.join(os.path.expanduser('~'), self.DATA_DIR_NAME)
-                else:
-                    self.__data_dir_path = data_dir
+    @classmethod
+    def instance(cls, path: str = None):
+        if not cls._instances:
+            cls._instances = {}
 
-            if not os.path.exists(self.__data_dir_path):
-                os.makedirs(self.__data_dir_path, exist_ok=True)
+        if not cls._instances.get(path):
+            cls._instances[path] = cls(path)
+
+        return cls._instances[path]
 
     @classmethod
-    def instance(cls):
-        if cls._instance is None:
-            cls._instance = cls()
+    def handle_chdir(cls):
+        if cls._instances and None in cls._instances:
+            del cls._instances[None]
 
-        return cls._instance
+        return cls.instance()
 
     @property
     def path(self):
@@ -137,9 +150,14 @@ class DataDir:
     def snapshosts_version_path(self):
         return os.path.join(self.snapshots_dir_path, 'VERSION')
 
-    def remove(self):
-        if os.path.exists(self.path):
-            shutil.rmtree(self.path) 
+    def remove(self, directory_path = None):
+        if directory_path:
+            data_dir_path = os.path.join(directory_path, self.DATA_DIR_NAME)
+        else:
+            data_dir_path = self.path
+
+        if os.path.exists(data_dir_path):
+            shutil.rmtree(data_dir_path) 
 
     def create(self, directory_path = None):
         if not directory_path:

stoobly_agent/lib/api/body_param_names_resource.py

@@ -7,6 +7,8 @@ from stoobly_agent.app.models.types import ParamNameCreateParams
 from ..logger import Logger
 from .endpoints_resource import EndpointsResource
 
+LOG_ID = 'BodyParamNamesResource'
+
 class BodyParamNamesResource(EndpointsResource):
   BODY_PARAM_NAMES_ENDPOINT = 'body_param_names'
 
@@ -17,20 +19,20 @@ class BodyParamNamesResource(EndpointsResource):
   def index(self, endpoint_id: int, query_params = {}) -> requests.Response:
     url = f"{self.service_url}/{self.ENDPOINTS_ENDPOINT}/{endpoint_id}/{self.BODY_PARAM_NAMES_ENDPOINT}"
 
-    Logger.instance().debug(f"{self.LOG_ID}.request_response:{url}?{urllib.parse.urlencode(query_params)}")
+    Logger.instance(LOG_ID).debug(f"{url}?{urllib.parse.urlencode(query_params)}")
 
     return self.get(url, headers=self.default_headers, params=query_params)
 
   def show(self, endpoint_id: int, body_param_name_id: int, query_params = {}) -> requests.Response:
     url = f"{self.service_url}/{self.ENDPOINTS_ENDPOINT}/{endpoint_id}/{self.BODY_PARAM_NAMES_ENDPOINT}/{body_param_name_id}"
 
-    Logger.instance().debug(f"{self.LOG_ID}.request_response:{url}?{urllib.parse.urlencode(query_params)}")
+    Logger.instance(LOG_ID).debug(f"{url}?{urllib.parse.urlencode(query_params)}")
 
     return self.get(url, headers=self.default_headers, params=query_params)
   
   def destroy(self, endpoint_id, body_param_name_id: int, query_params = {}) -> requests.Response:
     url = f"{self.service_url}/{self.ENDPOINTS_ENDPOINT}/{endpoint_id}/{self.BODY_PARAM_NAMES_ENDPOINT}/{body_param_name_id}"
 
-    Logger.instance().debug(f"{self.LOG_ID}.request_response:{url}?{urllib.parse.urlencode(query_params)}")
+    Logger.instance(LOG_ID).debug(f"{url}?{urllib.parse.urlencode(query_params)}")
 
     return self.delete(url, headers=self.default_headers, params=query_params)

stoobly_agent/lib/api/endpoints_resource.py

@@ -6,6 +6,8 @@ from ..logger import Logger
 from .interfaces import EndpointsIndexQueryParams
 from .stoobly_api import StooblyApi
 
+LOG_ID = 'EndpointsResource'
+
 class EndpointsResource(StooblyApi):
   ENDPOINTS_ENDPOINT = 'endpoints'
 
@@ -16,20 +18,20 @@ class EndpointsResource(StooblyApi):
   def index(self, **query_params: EndpointsIndexQueryParams) -> requests.Response:
     url = f"{self.service_url}/{self.ENDPOINTS_ENDPOINT}"
 
-    Logger.instance().debug(f"{self.LOG_ID}.request_response:{url}?{urllib.parse.urlencode(query_params)}")
+    Logger.instance(LOG_ID).debug(f"{url}?{urllib.parse.urlencode(query_params)}")
 
     return self.get(url, headers=self.default_headers, params=query_params)
 
   def show(self, endpoint_id: int, **query_params) -> requests.Response:
     url = f"{self.service_url}/{self.ENDPOINTS_ENDPOINT}/{endpoint_id}"
 
-    Logger.instance().debug(f"{self.LOG_ID}.request_response:{url}?{urllib.parse.urlencode(query_params)}")
+    Logger.instance(LOG_ID).debug(f"{url}?{urllib.parse.urlencode(query_params)}")
 
     return self.get(url, headers=self.default_headers, params=query_params)
 
   def destroy(self, endpoint_id: int, **query_params) -> requests.Response:
     url = f"{self.service_url}/{self.ENDPOINTS_ENDPOINT}/{endpoint_id}"
 
-    Logger.instance().debug(f"{self.LOG_ID}.request_response:{url}?{urllib.parse.urlencode(query_params)}")
+    Logger.instance(LOG_ID).debug(f"{url}?{urllib.parse.urlencode(query_params)}")
 
     return self.delete(url, headers=self.default_headers, params=query_params)

stoobly_agent/lib/api/header_names_resource.py

@@ -7,6 +7,8 @@ from stoobly_agent.app.models.types import HeaderNameCreateParams
 from ..logger import Logger
 from .endpoints_resource import EndpointsResource
 
+LOG_ID = 'HeaderNamesResource'
+
 class HeaderNamesResource(EndpointsResource):
   HEADER_NAMES_ENDPOINT = 'header_names'
 
@@ -17,20 +19,20 @@ class HeaderNamesResource(EndpointsResource):
   def index(self, endpoint_id: int, query_params = {}) -> requests.Response:
     url = f"{self.service_url}/{self.ENDPOINTS_ENDPOINT}/{endpoint_id}/{self.HEADER_NAMES_ENDPOINT}"
 
-    Logger.instance().debug(f"{self.LOG_ID}.request_response:{url}?{urllib.parse.urlencode(query_params)}")
+    Logger.instance(LOG_ID).debug(f"{url}?{urllib.parse.urlencode(query_params)}")
 
     return self.get(url, headers=self.default_headers, params=query_params)
 
   def show(self, endpoint_id: int, header_name_id: int, query_params = {}) -> requests.Response:
     url = f"{self.service_url}/{self.ENDPOINTS_ENDPOINT}/{endpoint_id}/{self.HEADER_NAMES_ENDPOINT}/{header_name_id}"
 
-    Logger.instance().debug(f"{self.LOG_ID}.request_response:{url}?{urllib.parse.urlencode(query_params)}")
+    Logger.instance(LOG_ID).debug(f"{url}?{urllib.parse.urlencode(query_params)}")
 
     return self.get(url, headers=self.default_headers, params=query_params)
   
   def destroy(self, endpoint_id: int, header_name_id: int, query_params = {}) -> requests.Response:
     url = f"{self.service_url}/{self.ENDPOINTS_ENDPOINT}/{endpoint_id}/{self.HEADER_NAMES_ENDPOINT}/{header_name_id}"
 
-    Logger.instance().debug(f"{self.LOG_ID}.request_response:{url}?{urllib.parse.urlencode(query_params)}")
+    Logger.instance(LOG_ID).debug(f"{url}?{urllib.parse.urlencode(query_params)}")
 
     return self.delete(url, headers=self.default_headers, params=query_params)