pycti 5.12.14__tar.gz → 5.12.15__tar.gz

{pycti-5.12.14 → pycti-5.12.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pycti
-Version: 5.12.14
+Version: 5.12.15
 Summary: Python API client for OpenCTI.
 Home-page: https://github.com/OpenCTI-Platform/client-python
 Author: Filigran

{pycti-5.12.14 → pycti-5.12.15}/pycti/__init__.py

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-__version__ = "5.12.14"
+__version__ = "5.12.15"
 
 from .api.opencti_api_client import OpenCTIApiClient
 from .api.opencti_api_connector import OpenCTIApiConnector

{pycti-5.12.14 → pycti-5.12.15}/pycti/api/opencti_api_client.py

@@ -3,16 +3,12 @@ import base64
 import datetime
 import io
 import json
-import logging
 from typing import Union
 
 import magic
 import requests
-import urllib3
-from pythonjsonlogger import jsonlogger
 
 from pycti import __version__
-from pycti.api import LOGGER
 from pycti.api.opencti_api_connector import OpenCTIApiConnector
 from pycti.api.opencti_api_playbook import OpenCTIApiPlaybook
 from pycti.api.opencti_api_work import OpenCTIApiWork
@@ -65,24 +61,10 @@ from pycti.entities.opencti_threat_actor_individual import ThreatActorIndividual
 from pycti.entities.opencti_tool import Tool
 from pycti.entities.opencti_vocabulary import Vocabulary
 from pycti.entities.opencti_vulnerability import Vulnerability
+from pycti.utils.opencti_logger import logger
 from pycti.utils.opencti_stix2 import OpenCTIStix2
 from pycti.utils.opencti_stix2_utils import OpenCTIStix2Utils
 
-urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
-
-
-class CustomJsonFormatter(jsonlogger.JsonFormatter):
-    def add_fields(self, log_record, record, message_dict):
-        super(CustomJsonFormatter, self).add_fields(log_record, record, message_dict)
-        if not log_record.get("timestamp"):
-            # This doesn't use record.created, so it is slightly off
-            now = datetime.datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%S.%fZ")
-            log_record["timestamp"] = now
-        if log_record.get("level"):
-            log_record["level"] = log_record["level"].upper()
-        else:
-            log_record["level"] = record.levelname
-
 
 class File:
     def __init__(self, name, data, mime="text/plain"):
@@ -141,19 +123,8 @@ class OpenCTIApiClient:
             raise ValueError("A TOKEN must be set")
 
         # Configure logger
-        log_level = log_level.upper()
-        LOGGER.setLevel(log_level)
-
-        if json_logging:
-            log_handler = logging.StreamHandler()
-            log_handler.setLevel(log_level)
-            formatter = CustomJsonFormatter(
-                "%(timestamp)s %(level)s %(name)s %(message)s"
-            )
-            log_handler.setFormatter(formatter)
-            logging.basicConfig(handlers=[log_handler], level=log_level, force=True)
-        else:
-            logging.basicConfig(level=log_level)
+        self.logger_class = logger(log_level.upper(), json_logging)
+        self.app_logger = self.logger_class("api")
 
         # Define API
         self.api_token = token
@@ -398,23 +369,6 @@ class OpenCTIApiClient:
             return base64.b64encode(r.text).decode("utf-8")
         return r.text
 
-    def log(self, level, message):
-        """log a message with defined log level
-        :param level: must be a valid logging log level (debug, info, warning, error)
-        :type level: str
-        :param message: the message to log
-        :type message: str
-        """
-
-        if level == "debug":
-            LOGGER.debug(message)
-        elif level == "info":
-            LOGGER.info(message)
-        elif level == "warning":
-            LOGGER.warning(message)
-        elif level == "error":
-            LOGGER.error(message)
-
     def health_check(self):
         """submit an example request to the OpenCTI API.
 
@@ -426,7 +380,7 @@ class OpenCTIApiClient:
             if test is not None:
                 return True
         except Exception as err:  # pylint: disable=broad-except
-            LOGGER.error("%s", err)
+            self.app_logger.error(str(err))
             return False
         return False
 
@@ -437,7 +391,7 @@ class OpenCTIApiClient:
         rtype: dict
         """
 
-        LOGGER.info("Getting logs worker config...")
+        self.app_logger.info("Getting logs worker config...")
         query = """
             query LogsWorkerConfig {
                 logsWorkerConfig {
@@ -638,7 +592,7 @@ class OpenCTIApiClient:
         data = kwargs.get("data", None)
         mime_type = kwargs.get("mime_type", "text/plain")
         if file_name is not None:
-            LOGGER.info("Uploading a file.")
+            self.app_logger.info("Uploading a file.")
             query = """
                 mutation UploadImport($file: Upload!) {
                     uploadImport(file: $file) {
@@ -656,7 +610,7 @@ class OpenCTIApiClient:
 
             return self.query(query, {"file": (File(file_name, data, mime_type))})
         else:
-            LOGGER.error("[upload] Missing parameter: file_name")
+            self.app_logger.error("[upload] Missing parameter: file_name")
             return None
 
     def upload_pending_file(self, **kwargs):
@@ -673,7 +627,7 @@ class OpenCTIApiClient:
         entity_id = kwargs.get("entity_id", None)
 
         if file_name is not None:
-            LOGGER.info("Uploading a file.")
+            self.app_logger.info("Uploading a file.")
             query = """
                     mutation UploadPending($file: Upload!, $entityId: String) {
                         uploadPending(file: $file, entityId: $entityId) {
@@ -693,7 +647,7 @@ class OpenCTIApiClient:
                 {"file": (File(file_name, data, mime_type)), "entityId": entity_id},
             )
         else:
-            LOGGER.error("[upload] Missing parameter: file_name")
+            self.app_logger.error("[upload] Missing parameter: file_name")
             return None
 
     def get_stix_content(self, id):
@@ -703,7 +657,7 @@ class OpenCTIApiClient:
         rtype: dict
         """
 
-        LOGGER.info("Entity in JSON %s", id)
+        self.app_logger.info("Entity in JSON", {"id": id})
         query = """
             query StixQuery($id: String!) {
                 stix(id: $id)

{pycti-5.12.14 → pycti-5.12.15}/pycti/api/opencti_api_connector.py

@@ -1,7 +1,6 @@
 import json
 from typing import Any, Dict
 
-from pycti.api import LOGGER
 from pycti.connector.opencti_connector import OpenCTIConnector
 
 
@@ -18,7 +17,7 @@ class OpenCTIApiConnector:
         :rtype: dict
         """
 
-        LOGGER.info("Getting connectors ...")
+        self.api.app_logger.info("Getting connectors ...")
         query = """
             query GetConnectors {
                 connectorsForWorker {

{pycti-5.12.14 → pycti-5.12.15}/pycti/api/opencti_api_playbook.py

@@ -1,6 +1,3 @@
-from pycti.api import LOGGER
-
-
 class OpenCTIApiPlaybook:
     """OpenCTIApiPlaybook"""
 
@@ -8,7 +5,9 @@ class OpenCTIApiPlaybook:
         self.api = api
 
     def playbook_step_execution(self, playbook: dict, bundle: str):
-        LOGGER.info("Executing playbook step %s", playbook["playbook_id"])
+        self.api.app_logger.info(
+            "Executing playbook step", {"playbook_id": playbook["playbook_id"]}
+        )
         query = """
             mutation PlaybookStepExecution($execution_id: ID!, $execution_start: DateTime!, $data_instance_id: ID!, $playbook_id: ID!, $previous_step_id: ID!, $step_id: ID!, $previous_bundle: String!, $bundle: String!) {
                 playbookStepExecution(execution_id: $execution_id, execution_start: $execution_start, data_instance_id: $data_instance_id, playbook_id: $playbook_id, previous_step_id: $previous_step_id, step_id: $step_id, previous_bundle: $previous_bundle, bundle: $bundle)

{pycti-5.12.14 → pycti-5.12.15}/pycti/api/opencti_api_work.py

@@ -1,8 +1,6 @@
 import time
 from typing import Dict, List
 
-from pycti.api import LOGGER
-
 
 class OpenCTIApiWork:
     """OpenCTIApiJob"""
@@ -11,7 +9,7 @@ class OpenCTIApiWork:
         self.api = api
 
     def to_received(self, work_id: str, message: str):
-        LOGGER.info("Reporting work update_received %s", work_id)
+        self.api.app_logger.info("Reporting work update_received", {"work_id": work_id})
         query = """
             mutation workToReceived($id: ID!, $message: String) {
                 workEdit(id: $id) {
@@ -22,7 +20,9 @@ class OpenCTIApiWork:
         self.api.query(query, {"id": work_id, "message": message})
 
     def to_processed(self, work_id: str, message: str, in_error: bool = False):
-        LOGGER.info("Reporting work update_processed %s", work_id)
+        self.api.app_logger.info(
+            "Reporting work update_processed", {"work_id": work_id}
+        )
         query = """
             mutation workToProcessed($id: ID!, $message: String, $inError: Boolean) {
                 workEdit(id: $id) {
@@ -33,7 +33,7 @@ class OpenCTIApiWork:
         self.api.query(query, {"id": work_id, "message": message, "inError": in_error})
 
     def ping(self, work_id: str):
-        LOGGER.info("Ping work %s", work_id)
+        self.api.app_logger.info("Ping work", {"work_id": work_id})
         query = """
             mutation pingWork($id: ID!) {
                 workEdit(id: $id) {
@@ -44,7 +44,7 @@ class OpenCTIApiWork:
         self.api.query(query, {"id": work_id})
 
     def report_expectation(self, work_id: str, error):
-        LOGGER.info("Report expectation for %s", work_id)
+        self.api.app_logger.info("Report expectation", {"work_id": work_id})
         query = """
             mutation reportExpectation($id: ID!, $error: WorkErrorInput) {
                 workEdit(id: $id) {
@@ -55,10 +55,13 @@ class OpenCTIApiWork:
         try:
             self.api.query(query, {"id": work_id, "error": error})
         except:
-            self.api.log("error", "Cannot report expectation")
+            self.api.app_logger.error("Cannot report expectation")
 
     def add_expectations(self, work_id: str, expectations: int):
-        LOGGER.info("Update action expectations %s - %s", work_id, expectations)
+        self.api.app_logger.info(
+            "Update action expectations",
+            {"work_id": work_id, "expectations": expectations},
+        )
         query = """
             mutation addExpectations($id: ID!, $expectations: Int) {
                 workEdit(id: $id) {
@@ -69,10 +72,10 @@ class OpenCTIApiWork:
         try:
             self.api.query(query, {"id": work_id, "expectations": expectations})
         except:
-            self.api.log("error", "Cannot report expectation")
+            self.api.app_logger.error("Cannot report expectation")
 
     def initiate_work(self, connector_id: str, friendly_name: str) -> str:
-        LOGGER.info("Initiate work for %s", connector_id)
+        self.api.app_logger.info("Initiate work", {"connector_id": connector_id})
         query = """
             mutation workAdd($connectorId: String!, $friendlyName: String) {
                 workAdd(connectorId: $connectorId, friendlyName: $friendlyName) {
@@ -107,8 +110,8 @@ class OpenCTIApiWork:
                 status = state["status"]
 
                 if state["errors"]:
-                    self.api.log(
-                        "error", f"Unexpected connector error {state['errors']}"
+                    self.api.app_logger.error(
+                        "Unexpected connector error", {"state_errors": state["errors"]}
                     )
                     return ""
 

{pycti-5.12.14 → pycti-5.12.15}/pycti/connector/opencti_connector_helper.py

@@ -3,7 +3,6 @@ import base64
 import copy
 import datetime
 import json
-import logging
 import os
 import queue
 import signal
@@ -22,7 +21,6 @@ from filigran_sseclient import SSEClient
 from pika.exceptions import NackError, UnroutableError
 
 from pycti.api.opencti_api_client import OpenCTIApiClient
-from pycti.connector import LOGGER
 from pycti.connector.opencti_connector import OpenCTIConnector
 from pycti.connector.opencti_metric_handler import OpenCTIMetricHandler
 from pycti.utils.opencti_stix2_splitter import OpenCTIStix2Splitter
@@ -30,8 +28,6 @@ from pycti.utils.opencti_stix2_splitter import OpenCTIStix2Splitter
 TRUTHY: List[str] = ["yes", "true", "True"]
 FALSY: List[str] = ["no", "false", "False"]
 
-logging.getLogger("pika").setLevel(logging.ERROR)
-
 
 def killProgramHook(etype, value, tb):
     traceback.print_exception(etype, value, tb)
@@ -220,7 +216,7 @@ class ListenQueue(threading.Thread):
         # Not ACK the message here may lead to infinite re-deliver if the connector is broken
         # Also ACK, will not have any impact on the blocking aspect of the following functions
         channel.basic_ack(delivery_tag=method.delivery_tag)
-        LOGGER.info("Message (delivery_tag=%s) ack", method.delivery_tag)
+        self.helper.connector_logger.info("Message ack", {"tag": method.delivery_tag})
 
         self.thread = threading.Thread(target=self._data_handler, args=[json_data])
         self.thread.start()
@@ -237,9 +233,9 @@ class ListenQueue(threading.Thread):
             else:
                 time_wait += 1
             time.sleep(1)
-        LOGGER.info(
-            "Message (delivery_tag=%s) processed, thread terminated",
-            method.delivery_tag,
+        self.helper.connector_logger.info(
+            "Message processed, thread terminated",
+            {"tag": method.delivery_tag},
         )
 
     def _data_handler(self, json_data) -> None:
@@ -281,13 +277,17 @@ class ListenQueue(threading.Thread):
                 self.helper.api.work.to_processed(work_id, message)
         except Exception as e:  # pylint: disable=broad-except
             self.helper.metric.inc("error_count")
-            LOGGER.exception("Error in message processing, reporting error to API")
+            self.helper.connector_logger.error(
+                "Error in message processing, reporting error to API"
+            )
             if work_id:
                 try:
                     self.helper.api.work.to_processed(work_id, str(e), True)
                 except:  # pylint: disable=bare-except
                     self.helper.metric.inc("error_count")
-                    LOGGER.error("Failing reporting the processing")
+                    self.helper.connector_logger.error(
+                        "Failing reporting the processing"
+                    )
 
     def run(self) -> None:
         while not self.exit_event.is_set():
@@ -310,7 +310,7 @@ class ListenQueue(threading.Thread):
                 try:
                     self.channel.confirm_delivery()
                 except Exception as err:  # pylint: disable=broad-except
-                    LOGGER.warning("%s", err)
+                    self.helper.connector_logger.warning(str(err))
                 self.channel.basic_qos(prefetch_count=1)
                 assert self.channel is not None
                 self.channel.basic_consume(
@@ -320,11 +320,11 @@ class ListenQueue(threading.Thread):
             except (KeyboardInterrupt, SystemExit):
                 self.channel.stop_consuming()
                 self.pika_connection.close()
-                LOGGER.info("Connector stop")
+                self.helper.connector_logger.info("Connector stop")
                 sys.exit(0)
             except Exception as err:  # pylint: disable=broad-except
                 self.pika_connection.close()
-                LOGGER.error("%s", err)
+                self.helper.connector_logger.error(str(err))
                 sys.exit(1)
 
     def stop(self):
@@ -335,8 +335,11 @@ class ListenQueue(threading.Thread):
 
 
 class PingAlive(threading.Thread):
-    def __init__(self, connector_id, api, get_state, set_state, metric) -> None:
+    def __init__(
+        self, connector_logger, connector_id, api, get_state, set_state, metric
+    ) -> None:
         threading.Thread.__init__(self)
+        self.connector_logger = connector_logger
         self.connector_id = connector_id
         self.in_error = False
         self.api = api
@@ -358,38 +361,39 @@ class PingAlive(threading.Thread):
                 )
                 if initial_state != remote_state:
                     self.set_state(result["connector_state"])
-                    LOGGER.info(
-                        'Connector state has been remotely reset to: "%s"',
-                        self.get_state(),
+                    self.connector_logger.info(
+                        "Connector state has been remotely reset",
+                        {"state": self.get_state()},
                     )
                 if self.in_error:
                     self.in_error = False
-                    LOGGER.error("API Ping back to normal")
+                    self.connector_logger.error("API Ping back to normal")
                 self.metric.inc("ping_api_count")
             except Exception:  # pylint: disable=broad-except
                 self.in_error = True
                 self.metric.inc("ping_api_error")
-                LOGGER.error("Error pinging the API")
+                self.connector_logger.error("Error pinging the API")
             self.exit_event.wait(40)
 
     def run(self) -> None:
-        LOGGER.info("Starting ping alive thread")
+        self.connector_logger.info("Starting ping alive thread")
         self.ping()
 
     def stop(self) -> None:
-        LOGGER.info("Preparing for clean shutdown")
+        self.connector_logger.info("Preparing for clean shutdown")
         self.exit_event.set()
 
 
 class StreamAlive(threading.Thread):
-    def __init__(self, q) -> None:
+    def __init__(self, helper, q) -> None:
         threading.Thread.__init__(self)
+        self.helper = helper
         self.q = q
         self.exit_event = threading.Event()
 
     def run(self) -> None:
         try:
-            LOGGER.info("Starting stream alive thread")
+            self.helper.connector_logger.info("Starting stream alive thread")
             time_since_last_heartbeat = 0
             while not self.exit_event.is_set():
                 time.sleep(5)
@@ -399,7 +403,7 @@ class StreamAlive(threading.Thread):
                 except queue.Empty:
                     time_since_last_heartbeat = time_since_last_heartbeat + 5
                     if time_since_last_heartbeat > 45:
-                        LOGGER.error(
+                        self.helper.connector_logger.error(
                             "Time since last heartbeat exceeded 45s, stopping the connector"
                         )
                         break
@@ -408,7 +412,7 @@ class StreamAlive(threading.Thread):
             sys.excepthook(*sys.exc_info())
 
     def stop(self) -> None:
-        LOGGER.info("Preparing for clean shutdown")
+        self.helper.connector_logger.info("Preparing for clean shutdown")
         self.exit_event.set()
 
 
@@ -474,7 +478,7 @@ class ListenStream(threading.Thread):
 
             # Start the stream alive watchdog
             q = Queue(maxsize=1)
-            stream_alive = StreamAlive(q)
+            stream_alive = StreamAlive(self.helper, q)
             stream_alive.start()
             # Computing args building
             live_stream_url = self.url
@@ -491,10 +495,14 @@ class ListenStream(threading.Thread):
             listen_delete = str(self.listen_delete).lower()
             no_dependencies = str(self.no_dependencies).lower()
             with_inferences = str(self.with_inferences).lower()
-            LOGGER.info(
-                'Starting to listen stream events on "%s" '
-                "(listen-delete: %s, no-dependencies: %s, with-inferences: %s)",
-                *(live_stream_url, listen_delete, no_dependencies, with_inferences),
+            self.helper.connector_logger.info(
+                "Starting to listen stream events",
+                {
+                    "live_stream_url": live_stream_url,
+                    "listen_delete": listen_delete,
+                    "no_dependencies": no_dependencies,
+                    "with_inferences": with_inferences,
+                },
             )
             messages = SSEClient(
                 live_stream_url,
@@ -660,10 +668,6 @@ class OpenCTIConnectorHelper:  # pylint: disable=too-many-public-methods
         metrics_port = get_config_variable(
             "CONNECTOR_METRICS_PORT", ["connector", "metrics_port"], config, True, 9095
         )
-        self.metric = OpenCTIMetricHandler(expose_metrics, metrics_port)
-
-        # Configure logger
-        logging.basicConfig(level=self.log_level)
 
         # Initialize configuration
         # - Classic API that will be directly attached to the connector rights
@@ -681,7 +685,17 @@ class OpenCTIConnectorHelper:  # pylint: disable=too-many-public-methods
             self.log_level,
             json_logging=self.opencti_json_logging,
         )
-
+        self.connector_logger = self.api.logger_class(self.connect_name)
+        # For retro compatibility
+        self.log_debug = self.connector_logger.debug
+        self.log_info = self.connector_logger.info
+        self.log_warning = self.connector_logger.warning
+        self.log_error = self.connector_logger.warning
+        # For retro compatibility
+
+        self.metric = OpenCTIMetricHandler(
+            self.connector_logger, expose_metrics, metrics_port
+        )
         # Register the connector in OpenCTI
         self.connector = OpenCTIConnector(
             self.connect_id,
@@ -693,7 +707,9 @@ class OpenCTIConnectorHelper:  # pylint: disable=too-many-public-methods
             playbook_compatible,
         )
         connector_configuration = self.api.connector.register(self.connector)
-        LOGGER.info("Connector registered with ID: %s", self.connect_id)
+        self.connector_logger.info(
+            "Connector registered with ID", {"id": self.connect_id}
+        )
         self.connector_id = connector_configuration["id"]
         self.work_id = None
         self.playbook = None
@@ -704,7 +720,12 @@ class OpenCTIConnectorHelper:  # pylint: disable=too-many-public-methods
         # Start ping thread
         if not self.connect_run_and_terminate:
             self.ping = PingAlive(
-                self.connector.id, self.api, self.get_state, self.set_state, self.metric
+                self.connector_logger,
+                self.connector.id,
+                self.api,
+                self.get_state,
+                self.set_state,
+                self.metric,
             )
             self.ping.start()
 
@@ -799,7 +820,7 @@ class OpenCTIConnectorHelper:  # pylint: disable=too-many-public-methods
                 self.api.connector.ping(self.connector_id, initial_state)
         except Exception:  # pylint: disable=broad-except
             self.metric.inc("error_count")
-            LOGGER.error("Error pinging the API")
+            self.connector_logger.error("Error pinging the API")
 
     def listen(self, message_callback: Callable[[Dict], str]) -> None:
         """listen for messages and register callback function
@@ -906,22 +927,6 @@ class OpenCTIConnectorHelper:  # pylint: disable=too-many-public-methods
     def get_connector(self) -> OpenCTIConnector:
         return self.connector
 
-    def log_error(self, msg: str, meta=None) -> None:
-        extra = None if meta is None else {"attributes": meta}
-        LOGGER.error(msg, exc_info=1, extra=extra)
-
-    def log_info(self, msg: str, meta=None) -> None:
-        extra = None if meta is None else {"attributes": meta}
-        LOGGER.info(msg, extra=extra)
-
-    def log_debug(self, msg: str, meta=None) -> None:
-        extra = None if meta is None else {"attributes": meta}
-        LOGGER.debug(msg, extra=extra)
-
-    def log_warning(self, msg: str, meta=None) -> None:
-        extra = None if meta is None else {"attributes": meta}
-        LOGGER.warning(msg, extra=extra)
-
     def date_now(self) -> str:
         """get the current date (UTC)
         :return: current datetime for utc
@@ -1022,7 +1027,7 @@ class OpenCTIConnectorHelper:  # pylint: disable=too-many-public-methods
         try:
             channel.confirm_delivery()
         except Exception as err:  # pylint: disable=broad-except
-            LOGGER.warning("%s", err)
+            self.connector_logger.warning(str(err))
         for sequence, bundle in enumerate(bundles, start=1):
             self._send_bundle(
                 channel,
@@ -1086,10 +1091,10 @@ class OpenCTIConnectorHelper:  # pylint: disable=too-many-public-methods
                     delivery_mode=2, content_encoding="utf-8"  # make message persistent
                 ),
             )
-            LOGGER.debug("Bundle has been sent")
+            self.connector_logger.debug("Bundle has been sent")
             self.metric.inc("bundle_send")
-        except (UnroutableError, NackError) as e:
-            LOGGER.error("Unable to send bundle, retry...%s", e)
+        except (UnroutableError, NackError):
+            self.connector_logger.error("Unable to send bundle, retry...")
             self.metric.inc("error_count")
             self._send_bundle(channel, bundle, **kwargs)
 

{pycti-5.12.14 → pycti-5.12.15}/pycti/connector/opencti_metric_handler.py

@@ -1,11 +1,10 @@
-import logging
 from typing import Type, Union
 
 from prometheus_client import Counter, Enum, start_http_server
 
 
 class OpenCTIMetricHandler:
-    def __init__(self, activated: bool = False, port: int = 9095):
+    def __init__(self, connector_logger, activated: bool = False, port: int = 9095):
         """
         Init of OpenCTIMetricHandler class.
 
@@ -17,8 +16,9 @@ class OpenCTIMetricHandler:
             Port for prometheus server.
         """
         self.activated = activated
+        self.connector_logger = connector_logger
         if self.activated:
-            logging.info(f"Exposing metrics on port {port}")
+            self.connector_logger.info("Exposing metrics on port", {"port": port})
             start_http_server(port)
             self._metrics = {
                 "bundle_send": Counter(
@@ -75,10 +75,13 @@ class OpenCTIMetricHandler:
             True if the metric exists and is of the correct type else False.
         """
         if name not in self._metrics:
-            logging.error(f"Metric {name} does not exist.")
+            self.connector_logger.error("Metric does not exist.", {"name": name})
             return False
         if not isinstance(self._metrics[name], expected_type):
-            logging.error(f"Metric {name} is not of expected type {expected_type}.")
+            self.connector_logger.error(
+                "Metric not of expected type",
+                {"name": name, "expected_type": expected_type},
+            )
             return False
         return True