Sindbad~EG File Manager

# coding=utf-8
#
# Copyright © Cloud Linux GmbH & Cloud Linux Software, Inc 2010-2019 All Rights Reserved
#
# Licensed under CLOUD LINUX LICENSE AGREEMENT
# http://cloudlinux.com/docs/LICENSE.TXT
from __future__ import absolute_import
import os
import time
import traceback

import logging  # pylint: disable=unused-import
import raven.processors
from clcommon import cpapi, get_lve_version
from clcommon.utils import get_rhn_systemid_value
from urllib.error import URLError
from raven import Client
from raven.transport import ThreadedHTTPTransport
from typing import Type, Tuple, Dict, Set  # pylint: disable=unused-import
from types import TracebackType  # pylint: disable=unused-import

import lvestats.version

DSN = "https://cc01305f0dfe416fb296832bf935916b:44f3f2725669428bbc99a23c4349388c@sentry.cloudlinux.com/4"


class RemoveConnectString(raven.processors.Processor):
    def filter_stacktrace(self, data):
        # type: (Dict) -> None
        for frame in data.get('frames', []):
            for variables in frame.get('vars', []):
                if isinstance(variables, dict):
                    variables.pop('connect_string', None)


class LveStatsSentryFilter(object):
    _record_list_file = "/var/lve/errors_record_list"
    _last_clean = time.time()
    _record_list_cache = set()  # type: Set[str]

    @classmethod
    def clear_record_list(cls):
        # type: () -> None
        cls._record_list_cache = set()
        try:
            os.unlink(cls._record_list_file)
        except OSError:
            pass

    @classmethod
    def _clean_muted_records(cls):
        if cls._last_clean < time.time() - 43200:  # more than 12 hours
            cls.clear_record_list()
            cls._last_clean = time.time()

    def in_record_list(self, record_fingerprint):
        # type: (str) -> bool
        try:
            with open(self._record_list_file, 'r') as f:
                result = [line.rstrip('\n') for line in f]
        except IOError:
            return False
        else:
            return record_fingerprint in result

    def append_to_record_list(self, record_fingerprint):
        # type: (str) -> None
        self._record_list_cache.add(record_fingerprint)
        try:
            with open(self._record_list_file, "a") as f:
                f.write(record_fingerprint + '\n')
        except IOError:
            pass

    def filter(self, record):
        # type: (logging.LogRecord) -> bool
        return self.check_fingerprint_absent(
            record.name,
            record.lineno,
            str(record.msg)[:25],
            record.exc_info[0].__name__ if record.exc_info else "")

    def check_fingerprint_absent(self, name, lineno, message, exc_name):
        # type: (str, int, str, str) -> bool
        if not os.environ.get('LVESTATSWITHOUTSENTRY'):
            record_fingerprint = repr("{0}.{1}.{2}.{3}".format(
                name, lineno, message, exc_name))
            self._clean_muted_records()
            if record_fingerprint in self._record_list_cache:
                return False
            elif self.in_record_list(record_fingerprint):
                self._record_list_cache.add(record_fingerprint)
                return False
            else:
                self.append_to_record_list(record_fingerprint)
                return True
        else:
            return False


class SafeThreadedHTTPTransport(ThreadedHTTPTransport):

    def send_sync(self, url, data, headers, success_cb, failure_cb):
        try:
            super(SafeThreadedHTTPTransport, self).send_sync(url, data, headers, success_cb, failure_cb)
        except URLError:
            # We hide errors while sending message to Sentry in varied cases:
            # problems with network, Sentry server is down, incorrect firewall's rules, etc
            pass


class LveStatsSentryClient(Client):
    _filter = LveStatsSentryFilter()

    def is_new_exception(self, exc_info):
        # type: (Tuple[Type, Exception, TracebackType]) -> bool
        type_, _, tb = exc_info
        filepath, line_no, _, _ = traceback.extract_tb(tb)[-1]
        name = os.path.basename(filepath)
        # 'message' param is not used here
        # line number and file must be enough
        return self._filter.check_fingerprint_absent(
            name, line_no, '', type_.__name__)

    def should_capture(self, exc_info):
        # type: (Tuple[Type, Exception, TracebackType]) -> bool
        return super(LveStatsSentryClient, self).should_capture(exc_info) \
               and self.is_new_exception(exc_info)


def init_sentry_client():
    client = LveStatsSentryClient(
        DSN,
        transport=SafeThreadedHTTPTransport,
    )
    # uncomment for lower issues count
    # client.sample_rate = 0.5
    client.auto_log_stacks = True
    client.string_max_length = 500
    client.user_context({"id": get_rhn_systemid_value("system_id")})
    try:
        client.tags["Email"] = cpapi.get_admin_email()
    except cpapi.NotSupported:
        client.tags["Email"] = "unknown"
    client.tags["Control Panel Name"] = cpapi.CP_NAME
    lve_version, _ = get_lve_version()
    client.tags["LVE"] = 'unknown' if lve_version is None else lve_version
    client.tags["Cloud Linux version"] = get_rhn_systemid_value("os_release")
    client.tags["Architecture"] = get_rhn_systemid_value("architecture")
    try:
        version = lvestats.version.VERSION.split(".el")
        release = version[0]
        is_developer = len(version[1]) > 2 or os.path.exists(
            "/root/rpmbuild/RPMS/noarch/lve-stats-{0}.noarch.rpm".format(lvestats.version.VERSION))
    except IndexError:
        release = lvestats.version.VERSION
        is_developer = True
    client.tags["Developer"] = is_developer
    client.release = release
    client.exclude_paths = ['sentry', 'raven']
    client.ignore_exceptions.add(SystemExit)
    client.ignore_exceptions.add(KeyboardInterrupt)
    client.ignore_exceptions.add("lvestats.eventloop.plugin_executors.PluginExecutionException")
    test_sentry_message(client=client)
    return client


def test_sentry_message(client):
    if os.environ.get('LVESTATSSENTRYDONTSEND'):
        def dont_send(data, headers, success_cb, failure_cb):
            time.sleep(0.5)

        transport = client.remote.get_transport()  # type: raven.transport.threaded.ThreadedHTTPTransport
        transport.send_sync = dont_send
        client.captureMessage('Something went fundamentally wrong')