SkullCyberArmy Bypass Shell - roomellotravel.com

Uname : Linux premium36.web-hosting.com 4.18.0-513.24.1.lve.1.el8.x86_64 #1 SMP Thu May 9 15:10:09 UTC 2024 x86_64
Soft : LiteSpeed
Ip : 198.54.115.237
Port : 443

File Name : logging.py

import logging
from datetime import datetime, timezone
from fnmatch import fnmatch

import sentry_sdk
from sentry_sdk.client import BaseClient
from sentry_sdk.utils import (
    safe_repr,
    to_string,
    event_from_exception,
    current_stacktrace,
    capture_internal_exceptions,
)
from sentry_sdk.integrations import Integration

from typing import TYPE_CHECKING, Tuple

if TYPE_CHECKING:
    from collections.abc import MutableMapping
    from logging import LogRecord
    from typing import Any
    from typing import Dict
    from typing import Optional

DEFAULT_LEVEL = logging.INFO
DEFAULT_EVENT_LEVEL = logging.ERROR
LOGGING_TO_EVENT_LEVEL = {
    logging.NOTSET: "notset",
    logging.DEBUG: "debug",
    logging.INFO: "info",
    logging.WARN: "warning",  # WARN is same a WARNING
    logging.WARNING: "warning",
    logging.ERROR: "error",
    logging.FATAL: "fatal",
    logging.CRITICAL: "fatal",  # CRITICAL is same as FATAL
}

# Capturing events from those loggers causes recursion errors. We cannot allow
# the user to unconditionally create events from those loggers under any
# circumstances.
#
# Note: Ignoring by logger name here is better than mucking with thread-locals.
# We do not necessarily know whether thread-locals work 100% correctly in the user's environment.
_IGNORED_LOGGERS = set(
    ["sentry_sdk.errors", "urllib3.connectionpool", "urllib3.connection"]
)

def ignore_logger(
    name,  # type: str
):
    # type: (...) -> None
    """This disables recording (both in breadcrumbs and as events) calls to
    a logger of a specific name.  Among other uses, many of our integrations
    use this to prevent their actions being recorded as breadcrumbs. Exposed
    to users as a way to quiet spammy loggers.

:param name: The name of the logger to ignore (same string you would pass to ``logging.getLogger``).
    """
    _IGNORED_LOGGERS.add(name)

class LoggingIntegration(Integration):
    identifier = "logging"

def __init__(
        self,
        level=DEFAULT_LEVEL,
        event_level=DEFAULT_EVENT_LEVEL,
        sentry_logs_level=DEFAULT_LEVEL,
    ):
        # type: (Optional[int], Optional[int], Optional[int]) -> None
        self._handler = None
        self._breadcrumb_handler = None
        self._sentry_logs_handler = None

if level is not None:
            self._breadcrumb_handler = BreadcrumbHandler(level=level)

if sentry_logs_level is not None:
            self._sentry_logs_handler = SentryLogsHandler(level=sentry_logs_level)

if event_level is not None:
            self._handler = EventHandler(level=event_level)

def _handle_record(self, record):
        # type: (LogRecord) -> None
        if self._handler is not None and record.levelno >= self._handler.level:
            self._handler.handle(record)

if (
            self._breadcrumb_handler is not None
            and record.levelno >= self._breadcrumb_handler.level
        ):
            self._breadcrumb_handler.handle(record)

if (
            self._sentry_logs_handler is not None
            and record.levelno >= self._sentry_logs_handler.level
        ):
            self._sentry_logs_handler.handle(record)

@staticmethod
    def setup_once():
        # type: () -> None
        old_callhandlers = logging.Logger.callHandlers

def sentry_patched_callhandlers(self, record):
            # type: (Any, LogRecord) -> Any
            # keeping a local reference because the
            # global might be discarded on shutdown
            ignored_loggers = _IGNORED_LOGGERS

try:
                return old_callhandlers(self, record)
            finally:
                # This check is done twice, once also here before we even get
                # the integration.  Otherwise we have a high chance of getting
                # into a recursion error when the integration is resolved
                # (this also is slower).
                if ignored_loggers is not None and record.name not in ignored_loggers:
                    integration = sentry_sdk.get_client().get_integration(
                        LoggingIntegration
                    )
                    if integration is not None:
                        integration._handle_record(record)

logging.Logger.callHandlers = sentry_patched_callhandlers  # type: ignore

class _BaseHandler(logging.Handler):
    COMMON_RECORD_ATTRS = frozenset(
        (
            "args",
            "created",
            "exc_info",
            "exc_text",
            "filename",
            "funcName",
            "levelname",
            "levelno",
            "linenno",
            "lineno",
            "message",
            "module",
            "msecs",
            "msg",
            "name",
            "pathname",
            "process",
            "processName",
            "relativeCreated",
            "stack",
            "tags",
            "taskName",
            "thread",
            "threadName",
            "stack_info",
        )
    )

def _can_record(self, record):
        # type: (LogRecord) -> bool
        """Prevents ignored loggers from recording"""
        for logger in _IGNORED_LOGGERS:
            if fnmatch(record.name, logger):
                return False
        return True

def _logging_to_event_level(self, record):
        # type: (LogRecord) -> str
        return LOGGING_TO_EVENT_LEVEL.get(
            record.levelno, record.levelname.lower() if record.levelname else ""
        )

def _extra_from_record(self, record):
        # type: (LogRecord) -> MutableMapping[str, object]
        return {
            k: v
            for k, v in vars(record).items()
            if k not in self.COMMON_RECORD_ATTRS
            and (not isinstance(k, str) or not k.startswith("_"))
        }

class EventHandler(_BaseHandler):
    """
    A logging handler that emits Sentry events for each log record

Note that you do not have to use this class if the logging integration is enabled, which it is by default.
    """

def emit(self, record):
        # type: (LogRecord) -> Any
        with capture_internal_exceptions():
            self.format(record)
            return self._emit(record)

def _emit(self, record):
        # type: (LogRecord) -> None
        if not self._can_record(record):
            return

client = sentry_sdk.get_client()
        if not client.is_active():
            return

client_options = client.options

# exc_info might be None or (None, None, None)
        #
        # exc_info may also be any falsy value due to Python stdlib being
        # liberal with what it receives and Celery's billiard being "liberal"
        # with what it sends. See
        # https://github.com/getsentry/sentry-python/issues/904
        if record.exc_info and record.exc_info[0] is not None:
            event, hint = event_from_exception(
                record.exc_info,
                client_options=client_options,
                mechanism={"type": "logging", "handled": True},
            )
        elif (record.exc_info and record.exc_info[0] is None) or record.stack_info:
            event = {}
            hint = {}
            with capture_internal_exceptions():
                event["threads"] = {
                    "values": [
                        {
                            "stacktrace": current_stacktrace(
                                include_local_variables=client_options[
                                    "include_local_variables"
                                ],
                                max_value_length=client_options["max_value_length"],
                            ),
                            "crashed": False,
                            "current": True,
                        }
                    ]
                }
        else:
            event = {}
            hint = {}

hint["log_record"] = record

level = self._logging_to_event_level(record)
        if level in {"debug", "info", "warning", "error", "critical", "fatal"}:
            event["level"] = level  # type: ignore[typeddict-item]
        event["logger"] = record.name

# Log records from `warnings` module as separate issues
        record_captured_from_warnings_module = (
            record.name == "py.warnings" and record.msg == "%s"
        )
        if record_captured_from_warnings_module:
            # use the actual message and not "%s" as the message
            # this prevents grouping all warnings under one "%s" issue
            msg = record.args[0]  # type: ignore

event["logentry"] = {
                "message": msg,
                "params": (),
            }

else:
            event["logentry"] = {
                "message": to_string(record.msg),
                "params": (
                    tuple(str(arg) if arg is None else arg for arg in record.args)
                    if record.args
                    else ()
                ),
            }

event["extra"] = self._extra_from_record(record)

sentry_sdk.capture_event(event, hint=hint)

# Legacy name
SentryHandler = EventHandler

class BreadcrumbHandler(_BaseHandler):
    """
    A logging handler that records breadcrumbs for each log record.

Note that you do not have to use this class if the logging integration is enabled, which it is by default.
    """

def emit(self, record):
        # type: (LogRecord) -> Any
        with capture_internal_exceptions():
            self.format(record)
            return self._emit(record)

def _emit(self, record):
        # type: (LogRecord) -> None
        if not self._can_record(record):
            return

sentry_sdk.add_breadcrumb(
            self._breadcrumb_from_record(record), hint={"log_record": record}
        )

def _breadcrumb_from_record(self, record):
        # type: (LogRecord) -> Dict[str, Any]
        return {
            "type": "log",
            "level": self._logging_to_event_level(record),
            "category": record.name,
            "message": record.message,
            "timestamp": datetime.fromtimestamp(record.created, timezone.utc),
            "data": self._extra_from_record(record),
        }

def _python_level_to_otel(record_level):
    # type: (int) -> Tuple[int, str]
    for py_level, otel_severity_number, otel_severity_text in [
        (50, 21, "fatal"),
        (40, 17, "error"),
        (30, 13, "warn"),
        (20, 9, "info"),
        (10, 5, "debug"),
        (5, 1, "trace"),
    ]:
        if record_level >= py_level:
            return otel_severity_number, otel_severity_text
    return 0, "default"

class SentryLogsHandler(_BaseHandler):
    """
    A logging handler that records Sentry logs for each Python log record.

Note that you do not have to use this class if the logging integration is enabled, which it is by default.
    """

def emit(self, record):
        # type: (LogRecord) -> Any
        with capture_internal_exceptions():
            self.format(record)
            if not self._can_record(record):
                return

client = sentry_sdk.get_client()
            if not client.is_active():
                return

if not client.options["_experiments"].get("enable_logs", False):
                return

SentryLogsHandler._capture_log_from_record(client, record)

@staticmethod
    def _capture_log_from_record(client, record):
        # type: (BaseClient, LogRecord) -> None
        scope = sentry_sdk.get_current_scope()
        otel_severity_number, otel_severity_text = _python_level_to_otel(record.levelno)
        attrs = {}  # type: dict[str, str | bool | float | int]
        if isinstance(record.msg, str):
            attrs["sentry.message.template"] = record.msg
        if record.args is not None:
            if isinstance(record.args, tuple):
                for i, arg in enumerate(record.args):
                    attrs[f"sentry.message.parameters.{i}"] = (
                        arg
                        if isinstance(arg, str)
                        or isinstance(arg, float)
                        or isinstance(arg, int)
                        or isinstance(arg, bool)
                        else safe_repr(arg)
                    )
        if record.lineno:
            attrs["code.line.number"] = record.lineno
        if record.pathname:
            attrs["code.file.path"] = record.pathname
        if record.funcName:
            attrs["code.function.name"] = record.funcName

if record.thread:
            attrs["thread.id"] = record.thread
        if record.threadName:
            attrs["thread.name"] = record.threadName

if record.process:
            attrs["process.pid"] = record.process
        if record.processName:
            attrs["process.executable.name"] = record.processName
        if record.name:
            attrs["logger.name"] = record.name

# noinspection PyProtectedMember
        client._capture_experimental_log(
            scope,
            {
                "severity_text": otel_severity_text,
                "severity_number": otel_severity_number,
                "body": record.message,
                "attributes": attrs,
                "time_unix_nano": int(record.created * 1e9),
                "trace_id": None,
            },
        )

Name	Type	Size	Permission	Last Modified	Actions
.	dir	-	0755	2025-04-04 08:00:48
..	dir	-	0755	2025-04-04 08:00:48
__pycache__	dir	-	0755	2025-04-04 08:00:48
celery	dir	-	0755	2025-04-04 08:00:48
django	dir	-	0755	2025-04-04 08:00:48
grpc	dir	-	0755	2025-04-04 08:00:48
opentelemetry	dir	-	0755	2025-04-04 08:00:48
redis	dir	-	0755	2025-04-04 08:00:48
spark	dir	-	0755	2025-04-04 08:00:48
__init__.py	text/x-script.python	9.95 KB	0644	2025-04-04 08:00:48
_asgi_common.py	text/x-script.python	3.11 KB	0644	2025-04-04 08:00:48
_wsgi_common.py	text/x-script.python	7.38 KB	0644	2025-04-04 08:00:48
aiohttp.py	text/x-script.python	12.59 KB	0644	2025-04-04 08:00:48
anthropic.py	text/x-script.python	9.21 KB	0644	2025-04-04 08:00:48
argv.py	text/x-script.python	911 B	0644	2025-04-04 08:00:48
ariadne.py	text/x-script.python	5.7 KB	0644	2025-04-04 08:00:48
arq.py	text/x-script.python	7.67 KB	0644	2025-04-04 08:00:48
asgi.py	text/plain	12.46 KB	0644	2025-04-04 08:00:48
asyncio.py	text/x-script.python	4.65 KB	0644	2025-04-04 08:00:48
asyncpg.py	text/x-script.python	6.37 KB	0644	2025-04-04 08:00:48
atexit.py	text/x-script.python	1.61 KB	0644	2025-04-04 08:00:48
aws_lambda.py	text/x-script.python	17.53 KB	0644	2025-04-04 08:00:48
beam.py	text/x-script.python	5.06 KB	0644	2025-04-04 08:00:48
boto3.py	text/x-script.python	4.31 KB	0644	2025-04-04 08:00:48
bottle.py	text/x-script.python	6.46 KB	0644	2025-04-04 08:00:48
chalice.py	text/x-script.python	4.59 KB	0644	2025-04-04 08:00:48
clickhouse_driver.py	text/x-script.python	5.12 KB	0644	2025-04-04 08:00:48
cloud_resource_context.py	text/x-script.python	7.6 KB	0644	2025-04-04 08:00:48
cohere.py	text/x-script.python	9.05 KB	0644	2025-04-04 08:00:48
dedupe.py	text/x-script.python	1.38 KB	0644	2025-04-04 08:00:48
dramatiq.py	text/x-script.python	5.45 KB	0644	2025-04-04 08:00:48
excepthook.py	text/x-script.python	2.35 KB	0644	2025-04-04 08:00:48
executing.py	text/x-script.python	1.95 KB	0644	2025-04-04 08:00:48
falcon.py	text/x-script.python	9.28 KB	0644	2025-04-04 08:00:48
fastapi.py	text/x-script.python	4.61 KB	0644	2025-04-04 08:00:48
flask.py	text/x-script.python	8.54 KB	0644	2025-04-04 08:00:48
gcp.py	text/x-script.python	8.08 KB	0644	2025-04-04 08:00:48
gnu_backtrace.py	text/x-script.python	2.83 KB	0644	2025-04-04 08:00:48
gql.py	text/x-script.python	4.08 KB	0644	2025-04-04 08:00:48
graphene.py	text/x-script.python	4.92 KB	0644	2025-04-04 08:00:48
httpx.py	text/x-script.python	5.73 KB	0644	2025-04-04 08:00:48
huey.py	text/x-script.python	5.32 KB	0644	2025-04-04 08:00:48
huggingface_hub.py	text/x-script.python	6.38 KB	0644	2025-04-04 08:00:48
langchain.py	text/x-script.python	17.3 KB	0644	2025-04-04 08:00:48
launchdarkly.py	text/x-script.python	1.9 KB	0644	2025-04-04 08:00:48
litestar.py	text/x-script.python	11.3 KB	0644	2025-04-04 08:00:48
logging.py	text/x-script.python	13.09 KB	0644	2025-04-04 08:00:48
loguru.py	text/x-script.python	3.77 KB	0644	2025-04-04 08:00:48
modules.py	text/x-script.python	820 B	0644	2025-04-04 08:00:48
openai.py	text/x-script.python	15.19 KB	0644	2025-04-04 08:00:48
openfeature.py	text/x-script.python	1.27 KB	0644	2025-04-04 08:00:48
pure_eval.py	text/x-script.python	4.47 KB	0644	2025-04-04 08:00:48
pymongo.py	text/x-script.python	6.23 KB	0644	2025-04-04 08:00:48
pyramid.py	text/x-script.python	7.19 KB	0644	2025-04-04 08:00:48
quart.py	text/x-script.python	7.26 KB	0644	2025-04-04 08:00:48
ray.py	text/x-script.python	4.06 KB	0644	2025-04-04 08:00:48
rq.py	text/x-script.python	5.18 KB	0644	2025-04-04 08:00:48
rust_tracing.py	text/plain	8.87 KB	0644	2025-04-04 08:00:48
sanic.py	text/x-script.python	12.66 KB	0644	2025-04-04 08:00:48
serverless.py	text/x-script.python	1.76 KB	0644	2025-04-04 08:00:48
socket.py	text/x-script.python	3.09 KB	0644	2025-04-04 08:00:48
sqlalchemy.py	text/x-script.python	4.27 KB	0644	2025-04-04 08:00:48
starlette.py	text/x-script.python	25.69 KB	0644	2025-04-04 08:00:48
starlite.py	text/x-script.python	10.37 KB	0644	2025-04-04 08:00:48
statsig.py	text/x-script.python	1.2 KB	0644	2025-04-04 08:00:48
stdlib.py	text/x-script.python	8.62 KB	0644	2025-04-04 08:00:48
strawberry.py	text/x-script.python	13.79 KB	0644	2025-04-04 08:00:48
sys_exit.py	text/x-script.python	2.43 KB	0644	2025-04-04 08:00:48
threading.py	text/x-script.python	3.92 KB	0644	2025-04-04 08:00:48
tornado.py	text/x-script.python	7.05 KB	0644	2025-04-04 08:00:48
trytond.py	text/x-script.python	1.61 KB	0644	2025-04-04 08:00:48
typer.py	text/x-script.python	1.77 KB	0644	2025-04-04 08:00:48
unleash.py	text/x-script.python	1.05 KB	0644	2025-04-04 08:00:48
wsgi.py	text/x-script.python	10.5 KB	0644	2025-04-04 08:00:48