ACIL FM

Nama	Ukuran	Aksi
integrations	-	Open
__pycache__	-	Open
api.py	4.69 MB	View DL Edit
attachments.py	1.75 MB	View DL Edit
client.py	14.03 MB	View DL Edit
consts.py	3.5 MB	View DL Edit
debug.py	1.11 MB	View DL Edit
envelope.py	8.17 MB	View DL Edit
hub.py	21.35 MB	View DL Edit
py.typed	0 B	View DL Edit
scope.py	15.62 MB	View DL Edit
serializer.py	15.92 MB	View DL Edit
sessions.py	7.67 MB	View DL Edit
tracing.py	25.24 MB	View DL Edit
transport.py	11.48 MB	View DL Edit
utils.py	26.26 MB	View DL Edit
worker.py	3.87 MB	View DL Edit
_compat.py	2.3 MB	View DL Edit
_functools.py	2.22 MB	View DL Edit
_queue.py	8.21 MB	View DL Edit
_types.py	1.26 MB	View DL Edit
__init__.py	854 B	View DL Edit

Edit file: /opt/imunify360/venv/lib/python3.11/site-packages/sentry_sdk/worker.py

import os
import threading

from time import sleep, time
from sentry_sdk._compat import check_thread_support
from sentry_sdk._queue import Queue, Full
from sentry_sdk.utils import logger

from sentry_sdk._types import MYPY

if MYPY:
    from typing import Any
    from typing import Optional
    from typing import Callable

_TERMINATOR = object()

class BackgroundWorker(object):
    def __init__(self, queue_size=30):
        # type: (int) -> None
        check_thread_support()
        self._queue = Queue(queue_size)  # type: Queue
        self._lock = threading.Lock()
        self._thread = None  # type: Optional[threading.Thread]
        self._thread_for_pid = None  # type: Optional[int]

@property
    def is_alive(self):
        # type: () -> bool
        if self._thread_for_pid != os.getpid():
            return False
        if not self._thread:
            return False
        return self._thread.is_alive()

def _ensure_thread(self):
        # type: () -> None
        if not self.is_alive:
            self.start()

def _timed_queue_join(self, timeout):
        # type: (float) -> bool
        deadline = time() + timeout
        queue = self._queue

queue.all_tasks_done.acquire()

try:
            while queue.unfinished_tasks:
                delay = deadline - time()
                if delay <= 0:
                    return False
                queue.all_tasks_done.wait(timeout=delay)

return True
        finally:
            queue.all_tasks_done.release()

def start(self):
        # type: () -> None
        with self._lock:
            if not self.is_alive:
                self._thread = threading.Thread(
                    target=self._target, name="raven-sentry.BackgroundWorker"
                )
                self._thread.setDaemon(True)
                self._thread.start()
                self._thread_for_pid = os.getpid()

def kill(self):
        # type: () -> None
        """
        Kill worker thread. Returns immediately. Not useful for
        waiting on shutdown for events, use `flush` for that.
        """
        logger.debug("background worker got kill request")
        with self._lock:
            if self._thread:
                try:
                    self._queue.put_nowait(_TERMINATOR)
                except Full:
                    logger.debug("background worker queue full, kill failed")

self._thread = None
                self._thread_for_pid = None

def flush(self, timeout, callback=None):
        # type: (float, Optional[Any]) -> None
        logger.debug("background worker got flush request")
        with self._lock:
            if self.is_alive and timeout > 0.0:
                self._wait_flush(timeout, callback)
        logger.debug("background worker flushed")

def _wait_flush(self, timeout, callback):
        # type: (float, Optional[Any]) -> None
        initial_timeout = min(0.1, timeout)
        if not self._timed_queue_join(initial_timeout):
            pending = self._queue.qsize()
            logger.debug("%d event(s) pending on flush", pending)
            if callback is not None:
                callback(pending, timeout)
            self._timed_queue_join(timeout - initial_timeout)

def submit(self, callback):
        # type: (Callable[[], None]) -> None
        self._ensure_thread()
        try:
            self._queue.put_nowait(callback)
        except Full:
            logger.debug("background worker queue full, dropping event")

def _target(self):
        # type: () -> None
        while True:
            callback = self._queue.get()
            try:
                if callback is _TERMINATOR:
                    break
                try:
                    callback()
                except Exception:
                    logger.error("Failed processing job", exc_info=True)
            finally:
                self._queue.task_done()
            sleep(0)

Batal