ULTRA [ resource.optimyar.com ]

Linux uranus.pws-dns.net 5.14.0-570.46.1.el9_6.x86_64 #1 SMP PREEMPT_DYNAMIC Wed Sep 24 05:41:59 EDT 2025 x86_64

LiteSpeed

31.214.174.197 | Your IP: 216.73.216.214

Cant read [ /etc/named.conf ]

[ drwxr-xr-x ]

/ proc / self / root / opt / cloudlinux / venv / lib / python3.11 / site-packages / raven /

Home Upload Mass Deface Mass Delete Back Connect Notify

processors.py

"""
raven.core.processors
~~~~~~~~~~~~~~~~~~~~~

:copyright: (c) 2010-2012 by the Sentry Team, see AUTHORS for more details.
:license: BSD, see LICENSE for more details.
"""
from __future__ import absolute_import

import re
import warnings

from raven.utils.compat import string_types, text_type, PY3
from raven.utils import varmap

class Processor(object):
    def __init__(self, client):
        self.client = client

def get_data(self, data, **kwargs):
        return

def process(self, data, **kwargs):
        resp = self.get_data(data, **kwargs)
        if resp:
            data = resp

if 'exception' in data:
            if 'values' in data['exception']:
                for value in data['exception'].get('values', []):
                    if 'stacktrace' in value:
                        self.filter_stacktrace(value['stacktrace'])

if 'request' in data:
            self.filter_http(data['request'])

if 'extra' in data:
            data['extra'] = self.filter_extra(data['extra'])

return data

def filter_stacktrace(self, data):
        pass

def filter_http(self, data):
        pass

def filter_extra(self, data):
        return data

class RemovePostDataProcessor(Processor):
    """Removes HTTP post data."""

def filter_http(self, data, **kwargs):
        data.pop('data', None)

class RemoveStackLocalsProcessor(Processor):
    """Removes local context variables from stacktraces."""

def filter_stacktrace(self, data, **kwargs):
        for frame in data.get('frames', []):
            frame.pop('vars', None)

class SanitizeKeysProcessor(Processor):
    """
    Asterisk out things that correspond to a configurable set of keys.
    """

MASK = '*' * 8

@property
    def sanitize_keys(self):
        keys = getattr(self.client, 'sanitize_keys')
        if keys is None:
            raise ValueError('The sanitize_keys setting must be present to use SanitizeKeysProcessor')
        return keys

def sanitize(self, item, value):
        if value is None:
            return

if not item:  # key can be a NoneType
            return value

# Just in case we have bytes here, we want to make them into text
        # properly without failing so we can perform our check.
        if isinstance(item, bytes):
            item = item.decode('utf-8', 'replace')
        else:
            item = text_type(item)

item = item.lower()
        for key in self.sanitize_keys:
            if key in item:
                # store mask as a fixed length for security
                return self.MASK
        return value

def filter_stacktrace(self, data):
        for frame in data.get('frames', []):
            if 'vars' not in frame:
                continue
            frame['vars'] = varmap(self.sanitize, frame['vars'])

def filter_http(self, data):
        for n in ('data', 'cookies', 'headers', 'env', 'query_string'):
            if n not in data:
                continue

# data could be provided as bytes
            if PY3 and isinstance(data[n], bytes):
                data[n] = data[n].decode('utf-8', 'replace')

if isinstance(data[n], string_types) and '=' in data[n]:
                # at this point we've assumed it's a standard HTTP query
                # or cookie
                if n == 'cookies':
                    delimiter = ';'
                else:
                    delimiter = '&'

data[n] = self._sanitize_keyvals(data[n], delimiter)
            else:
                data[n] = varmap(self.sanitize, data[n])
                if n == 'headers' and 'Cookie' in data[n]:
                    data[n]['Cookie'] = self._sanitize_keyvals(
                        data[n]['Cookie'], ';'
                    )

def filter_extra(self, data):
        return varmap(self.sanitize, data)

def _sanitize_keyvals(self, keyvals, delimiter):
        sanitized_keyvals = []
        for keyval in keyvals.split(delimiter):
            keyval = keyval.split('=')
            if len(keyval) == 2:
                sanitized_keyvals.append((keyval[0], self.sanitize(*keyval)))
            else:
                sanitized_keyvals.append(keyval)

return delimiter.join('='.join(keyval) for keyval in sanitized_keyvals)

class SanitizePasswordsProcessor(SanitizeKeysProcessor):
    """
    Asterisk out things that look like passwords, credit card numbers,
    and API keys in frames, http, and basic extra data.
    """

KEYS = frozenset([
        'password',
        'secret',
        'passwd',
        'authorization',
        'api_key',
        'apikey',
        'sentry_dsn',
        'access_token',
    ])
    VALUES_RE = re.compile(r'^(?:\d[ -]*?){13,16}$')

@property
    def sanitize_keys(self):
        return self.KEYS

@property
    def FIELDS(self):
        warnings.warn(
            "`SanitizePasswordsProcessor.Fields` has been deprecated. Use "
            "`SanitizePasswordsProcessor.KEYS` or `SanitizePasswordsProcessor.sanitize_keys` "
            "instead",
            DeprecationWarning,
        )
        return self.KEYS

def sanitize(self, item, value):
        value = super(SanitizePasswordsProcessor, self).sanitize(item, value)
        if isinstance(value, string_types) and self.VALUES_RE.match(value):
            return self.MASK
        return value

Name	Type	Size	Owner/Group	Permission	Last Modified	Actions
.	dir	-	root/root	drwxr-xr-x	2025-04-23 11:34:19
..	dir	-	root/root	drwxr-xr-x	2025-10-08 11:28:40
__pycache__	dir	-	root/root	drwxr-xr-x	2025-04-23 11:34:19
conf	dir	-	root/root	drwxr-xr-x	2025-04-23 11:34:19
contrib	dir	-	root/root	drwxr-xr-x	2025-04-23 11:34:19
data	dir	-	root/root	drwxr-xr-x	2025-04-23 11:34:19
handlers	dir	-	root/root	drwxr-xr-x	2025-04-23 11:34:19
scripts	dir	-	root/root	drwxr-xr-x	2025-04-23 11:34:19
transport	dir	-	root/root	drwxr-xr-x	2025-04-23 11:34:19
utils	dir	-	root/root	drwxr-xr-x	2025-04-23 11:34:19
__init__.py	text/plain	1.21 KB	root/root	-rw-r--r--	2025-04-17 01:12:16
base.py	text/plain	29.4 KB	root/root	-rw-r--r--	2025-04-17 01:12:16
breadcrumbs.py	text/x-script.python	12.91 KB	root/root	-rw-r--r--	2025-04-17 01:12:16
context.py	text/plain	3.78 KB	root/root	-rw-r--r--	2025-04-17 01:12:16
events.py	text/plain	4.56 KB	root/root	-rw-r--r--	2025-04-17 01:12:16
exceptions.py	text/x-script.python	620 B	root/root	-rw-r--r--	2025-04-17 01:12:16
middleware.py	text/plain	3.51 KB	root/root	-rw-r--r--	2025-04-17 01:12:16
processors.py	text/plain	5.26 KB	root/root	-rw-r--r--	2025-04-17 01:12:16
versioning.py	text/x-script.python	2.48 KB	root/root	-rw-r--r--	2025-04-17 01:12:16