ACIL FM

Nama	Ukuran	Aksi
crons	-	Open
integrations	-	Open
__pycache__	-	Open
api.py	6.05 MB	View DL Edit
attachments.py	1.77 MB	View DL Edit
client.py	22.35 MB	View DL Edit
consts.py	8.49 MB	View DL Edit
debug.py	1.11 MB	View DL Edit
envelope.py	9.37 MB	View DL Edit
hub.py	26.42 MB	View DL Edit
monitor.py	2.97 MB	View DL Edit
profiler.py	33.18 MB	View DL Edit
py.typed	0 B	View DL Edit
scope.py	24.26 MB	View DL Edit
scrubber.py	3.8 MB	View DL Edit
serializer.py	12.97 MB	View DL Edit
session.py	5.43 MB	View DL Edit
sessions.py	5.76 MB	View DL Edit
tracing.py	29.04 MB	View DL Edit
tracing_utils.py	12 MB	View DL Edit
tracing_utils_py2.py	1.21 MB	View DL Edit
tracing_utils_py3.py	2.1 MB	View DL Edit
transport.py	18.13 MB	View DL Edit
utils.py	45.58 MB	View DL Edit
worker.py	4.15 MB	View DL Edit
_compat.py	2.73 MB	View DL Edit
_functools.py	4.84 MB	View DL Edit
_lru_cache.py	5.26 MB	View DL Edit
_queue.py	11 MB	View DL Edit
_types.py	2.19 MB	View DL Edit
_werkzeug.py	3.7 MB	View DL Edit
__init__.py	1.03 MB	View DL Edit

Edit file: /opt/cloudlinux/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, FullError
from sentry_sdk.utils import logger
from sentry_sdk.consts import DEFAULT_QUEUE_SIZE

from sentry_sdk._types import TYPE_CHECKING

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

_TERMINATOR = object()

class BackgroundWorker(object):
    def __init__(self, queue_size=DEFAULT_QUEUE_SIZE):
        # 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.daemon = 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 FullError:
                    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 full(self):
        # type: () -> bool
        return self._queue.full()

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() + 1
            logger.debug("%d event(s) pending on flush", pending)
            if callback is not None:
                callback(pending, timeout)

if not self._timed_queue_join(timeout - initial_timeout):
                pending = self._queue.qsize() + 1
                logger.error("flush timed out, dropped %s events", pending)

def submit(self, callback):
        # type: (Callable[[], None]) -> bool
        self._ensure_thread()
        try:
            self._queue.put_nowait(callback)
            return True
        except FullError:
            return False

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