Gecko [ tanishkshah.com ]

Name	Size	Permission	Date
__pycache__	[ DIR ]	drwxr-xr-x	2026-09-04 11:34
chek_mysql_rpms_local	1.79 KB	-rwxr-xr-x	2026-08-06 17:01
cpanel-common-lve	2.16 KB	-rwxr-xr-x	2026-08-06 17:01
cpanel-delete-hooks	1.98 KB	-rwxr-xr-x	2026-08-06 17:01
cpanel-install-hooks	3.48 KB	-rwxr-xr-x	2026-08-06 17:01
cpanel-mysql-url-detect.pm	1.6 KB	-rwxr-xr-x	2026-08-06 17:01
cpanel_map_rebuilder	1.5 KB	-rwxr-xr-x	2026-08-06 17:01
dbgovernor_map	4.15 KB	-rwxr-xr-x	2026-08-06 17:01
dbgovernor_map.py	3.16 KB	-rwxr-xr-x	2026-08-06 17:01
dbgovernor_map_plesk.py	4.21 KB	-rwxr-xr-x	2026-08-06 17:01
dbgovernor_version.py	28 B	-rw-r--r--	2026-08-06 17:01
dbgovernor_watchdog.py	7.03 KB	-rwxr-xr-x	2026-08-06 17:01
detect-cpanel-mysql-version.pm	4.83 KB	-rwxr-xr-x	2026-08-06 17:01
map_hook	664 B	-rwxr-xr-x	2026-08-06 17:01
merge_logs.py	984 B	-rwxr-xr-x	2026-08-06 17:01
mysql_backup.sh	24.38 KB	-rwxr-xr-x	2026-08-06 17:01
mysql_hook	42 B	-rwxr-xr-x	2026-08-06 17:01
sentry_cleaner.sh	1.21 KB	-rwxr-xr-x	2026-08-06 17:01
sentry_daemon.py	19.72 KB	-rwxr-xr-x	2026-08-06 17:01
sentry_sdk_wrapper.py	7.14 KB	-rwxr-xr-x	2026-08-06 17:01
set_cpanel_mysql_version.pm	381 B	-rwxr-xr-x	2026-08-06 17:01
sync_hook	501 B	-rwxr-xr-x	2026-08-06 17:01

Rename

#!/opt/cloudlinux/venv/bin/python3
# coding:utf-8

# Copyright © Cloud Linux GmbH & Cloud Linux Software, Inc 2010-2024 All Rights Reserved
#
# Licensed under CLOUD LINUX LICENSE AGREEMENT
# http://cloudlinux.com/docs/LICENSE.TXT
#

import os
import sys
import platform
import sentry_sdk
from sentry_sdk.integrations.logging import LoggingIntegration
import logging
from clcommon.utils import get_rhn_systemid_value
from clcommon import get_lve_version
from clcommon.lib.cledition import get_cl_edition_readable
from clcommon.lib.network import get_ip_addr, get_hostname
from clsentry.utils import get_pkg_version
from dbgovernor_version import GOVERNOR_CUR_VER

sys.path.append(os.path.dirname(os.path.realpath(__file__)) + "/../")  # utilities.py lives one level higher
from utilities import exec_command

SENTRY_DSN_FILE = "/usr/share/lve/dbgovernor/sentry-dsn"

"""
    Wrapper around sentry_sdk.
    Provides CL-specific tags to Sentry events.
    Accommodates events to our Sentry server-side version.
"""

# Set True when init() skips sentry_sdk because no DSN is shipped. Distinguishes
# "telemetry intentionally disabled" from "transport down" so the daemon does not
# mistake a quiescent, never-initialised client for an event-loss condition.
_telemetry_disabled = False

def telemetry_disabled():
    """True when init() skipped sentry_sdk because telemetry is disabled (no DSN)."""
    return _telemetry_disabled

def init():
    """
    Initialize.
    """

global _telemetry_disabled

try:
        with open(SENTRY_DSN_FILE) as f:
            dsn = f.read().strip()
    except OSError:
        dsn = ""
    if not dsn:  # no DSN shipped -> telemetry disabled, nothing to initialise
        _telemetry_disabled = True
        return
    _telemetry_disabled = False

os_name = get_rhn_systemid_value('operating_system')
    os_version = get_rhn_systemid_value('os_release')
    os2 = [s for s in exec_command("cldetect --detect-os", as_string=True, no_debug_log=True).split(" ") if s]  # do this before sentry_sdk.init(): not only because these are constants, but also to avoid 'subprocess' calls being put into breadcrumbs:
    if len(os2) == 2:
        os_name, os_version = os2

sentry_sdk.init(
        dsn = dsn,
        #debug = True,                   # uncomment to look deeper under the hood of 'sentry_sdk'
        before_send = before_send,       # to strip away undesirable event attributes
        release = GOVERNOR_CUR_VER,      # version of db_governor/libgovernor.so
        integrations = [LoggingIntegration(event_level=logging.WARNING)],  # this kind of integration is set manually only to set non-default 'event_level'
        send_client_reports = False      # our Sentry server doesn't like 'client_report' events and responds with HTTP '400 Bad Request'
    )
    with sentry_sdk.configure_scope() as scope:  # set permanent tags
        scope.set_user({ "id":        VIS(get_rhn_systemid_value('system_id'))})
        scope.set_context("device", {
            "architecture":           VIS(get_rhn_systemid_value("architecture") or platform.machine())
        })
        scope.set_context("os", {
            "name":                   VIS(os_name),
            "version":                VIS(os_version),
            "build":                  VIS(platform.version()),
            "Kernel-version":         VIS(platform.release()),
            "CloudLinux-edition":     VIS(get_cl_edition_readable())
        })
        scope.set_tag("lve.version",  VIS(get_lve_version()[0]))
        scope.set_tag("lvemanager",   VIS(get_pkg_version("lvemanager")))
        scope.set_tag("lve-stats",    VIS(get_pkg_version("lve-stats")))
        scope.set_tag("lve-utils",    VIS(get_pkg_version("lve-utils")))
        scope.set_tag("ip_address",   VIS(get_ip_addr(get_hostname())))

def is_healthy():
    client = sentry_sdk.Hub.current.client
    if client is None:  # init() skipped (no DSN): telemetry disabled, not a transport failure
        return True
    return client.transport.is_healthy()

strip_event_pythonicity = False

MAX_MESSAGE_LEN = 256  # cap free-form text so we keep an error signature without forwarding full command output

def _redact_payload(event):
    # Data minimisation: free-form bodies and captured command output may carry
    # usernames, paths and stdout/stderr. Keep release/version/contexts tags
    # (needed for triage) but strip the sensitive payloads before upload.
    msg = event.get("message")
    if isinstance(msg, str) and len(msg) > MAX_MESSAGE_LEN:
        event["message"] = msg[:MAX_MESSAGE_LEN] + "...[truncated]"
    logentry = event.get("logentry")
    if isinstance(logentry, dict):
        formatted = logentry.get("formatted")
        if isinstance(formatted, str) and len(formatted) > MAX_MESSAGE_LEN:
            logentry["formatted"] = formatted[:MAX_MESSAGE_LEN] + "...[truncated]"
        message = logentry.get("message")
        if isinstance(message, str) and len(message) > MAX_MESSAGE_LEN:
            logentry["message"] = message[:MAX_MESSAGE_LEN] + "...[truncated]"
    # drop free-form / locals payloads entirely - no diagnostic value worth the disclosure
    event.pop("extra", None)
    event.pop("server_name", None)
    tags = event.get("tags")
    if isinstance(tags, dict):
        tags.pop("username", None)
    # strip captured local variables (may embed stdout/stderr, args) from stack frames
    for entry in event.get("exception", {}).get("values", []) if isinstance(event.get("exception"), dict) else []:
        if not isinstance(entry, dict):
            continue
        # cap the exception type/value: the depot daemon forwards the parsed log line
        # as exception.values[0].type, so it must be minimised like message/logentry
        for key in ("type", "value"):
            text = entry.get(key)
            if isinstance(text, str) and len(text) > MAX_MESSAGE_LEN:
                entry[key] = text[:MAX_MESSAGE_LEN] + "...[truncated]"
        for frame in entry.get("stacktrace", {}).get("frames", []) if isinstance(entry.get("stacktrace"), dict) else []:
            frame.pop("vars", None)
    return event

def before_send(event, hint):
    event.pop("transaction_info", None)  # our Sentry server doesn't understand it and throws a pink msg box "There was 1 error encountered while processing this event: transaction_info: Discarded unknown attribute". Possibly it will go away after Sentry server upgrade.
    event = _redact_payload(event)
    global strip_event_pythonicity
    if strip_event_pythonicity:  # remove irrelevant attributes - misleading and obstructing for events forwarded from C code
        if "extra" in event:
            event["extra"].pop("sys.argv", None)
        if "contexts" in event:
            event["contexts"].pop("runtime", None)
        for attr in ("modules", "sdk", "breadcrumbs"):
            event.pop(attr, None)
    return event

def VIS(x):
    """
    Visualize - replace anything "pythonically Falsy" with an explicit "n/a".

There are Sentry tags that we consider mandatory for a regular machine.
    Although, sometimes the corresponding values can be None,
    and set_tag(..., None) wouldn't make them visible on the Sentry page.
    We wrap them in this call to force visibility.
    """
    return x if x else "n/a"