AlkantarClanX12
Your IP : 13.59.183.186
# -*- coding: utf-8 -*-
# Copyright © Cloud Linux GmbH & Cloud Linux Software, Inc 2010-2021 All Rights Reserved
#
# Licensed under CLOUD LINUX LICENSE AGREEMENT
# http://cloudlinux.com/docs/LICENSE.TXT
"""
This module contains SSA classes for sending e-mails with report
and sending reports to ClickHouse
"""
__package__ = 'ssa.modules'
import json
import logging
import subprocess
from email.message import EmailMessage
from functools import partial
from typing import Optional, Any
from socket import gethostname
from clcommon.cpapi import get_admin_email
from requests import Session, Response
from requests.adapters import HTTPAdapter
from requests.exceptions import RequestException
from requests.packages.urllib3.util.retry import Retry
from .common import Common
from .decision_maker import DecisionMaker
from ..internal.constants import stat_server
from ..internal.exceptions import SSAError
from ..internal.mailer import Mailer, render_report_table
from ..internal.utils import read_sys_id, sentry_init, duration_cast, \
format_date
class StatisticsSender(Common):
"""
Send report to ClickHouse and over e-mails
"""
def __init__(self, ch_endpoint: str = f'https://{stat_server}/api/clos-ssa'):
super().__init__()
self.logger = logging.getLogger('stat_sender')
self.logger.info('StatisticsSender enabled: %s', __package__)
self.sys_id = read_sys_id()
self.ch_endpoint = ch_endpoint
self.mail_sender = Mailer()
retry_conf = Retry(total=3,
allowed_methods=frozenset(['POST']),
status_forcelist=frozenset([502, 503, 504]),
backoff_factor=3) # sleeps 0s, 6s, 18s
adapter = HTTPAdapter(max_retries=retry_conf)
self.session = Session()
self.session.mount('https://', adapter)
self.session.request = partial(self.session.request, timeout=10)
def send(self, report: dict = None) -> None:
"""
Send given report over e-mail
If no report given, get it from DecisionMaker API
"""
if report is None:
report = DecisionMaker().get_json_report()
if self.summary_notification_enabled:
self.email_report(report)
self.clickhouse_report(report)
def email_report(self, report_view: dict) -> Optional[EmailMessage]:
"""
Create and send e-mail with report
"""
mail_to = self.get_mail_recipient()
if mail_to and report_view.get('domains'):
report_table, mail = render_report_table(report_view)
msg = self.mail_sender._message(
recipient=mail_to,
template='ssa_report',
date=format_date(report_view['date']),
hostname=gethostname(),
html=mail
)
msg.add_attachment(json.dumps(report_view),
subtype='json',
filename=f"report_{report_view['date']}.json")
msg.add_attachment(report_table,
subtype='html',
filename=f"report_{report_view['date']}.html")
self.mail_sender._send(msg)
return msg
def get_mail_recipient(self) -> Optional[str]:
"""
Retrieve a recipient's e-mail:
1. get address from a wmt-api utility
2. if command failed or address is empty, get address of server admin
"""
try:
# get_admin_email could return '', None, or throw unexpected errors
return self.wmt_api_report_email() or get_admin_email()
except Exception as e:
self.logger.error('get_admin_email failed with: %s', str(e))
def wmt_api_report_email(self) -> Optional[str]:
"""
Retrieve a recipient's e-mail address from WMT API
"""
_util = 'wmt-api'
try:
api_response = subprocess.run(
[f'/usr/share/web-monitoring-tool/wmtbin/{_util}',
'--config-get'],
check=True, text=True,
capture_output=True).stdout.strip()
except (subprocess.CalledProcessError, AttributeError, OSError,
ValueError) as e:
self.logger.error('wmt-api utility failed: %s', str(e))
return
try:
return json.loads(api_response).get('config').get('report_email')
except json.JSONDecodeError as e:
self.logger.error('wmt-api returned invalid json: %s',
str(e))
except AttributeError:
self.logger.error('wmt-api returned unexpected response: %s',
api_response)
def clickhouse_report(self, report_view: dict) -> bool:
"""
Send report to ClickHouse
"""
if report_view.get('domains'):
self.logger.info('Sending POST request to %s',
self.ch_endpoint)
try:
resp = self.session.post(self.ch_endpoint, json=self._ch_pack(
self.clickhouse_format(report_view)))
except RequestException as e:
self.logger.error('POST failed with %s', e,
extra={'endpoint': self.ch_endpoint})
raise SSAError(
f'Failed to POST data to SSA API server: {str(e)}') from e
return self._process_response(resp)
else:
self.logger.info('Report is empty, not sending to ClickHouse')
return False
@staticmethod
def _ch_pack(value: Any) -> dict:
"""
Pack given value into data field of a dict
"""
return dict(data=value)
def clickhouse_format(self, original_report: dict) -> list:
"""
Format local report for sending to ClickHouse
(required structures differ)
"""
ch_report = list()
for domain in original_report.get('domains'):
ch_report.append({
'system_id': self.sys_id,
'domain': domain.get('name'),
'count_slow_urls': domain.get('slow_urls'),
'count_slow_requests': domain.get('slow_reqs'),
'total_requests': domain.get('total_reqs'),
'details': [
{
"url": u.get('name'),
"count_requests": u.get('reqs_num'),
"avg_duration": duration_cast(
u.get('average_duration')),
"correlation": float(u.get('correlation', 0))
} for u in domain.get('urls')
]
})
return ch_report
def _process_response(self, response: Response) -> bool:
"""
Check received response
:param response: a requests.Response object
:return: True in case of success, False otherwise
"""
if not response.ok:
self.logger.error('Unable to connect to server with %s:%s',
response.status_code, response.reason,
extra={'resp_text': response.text})
return False
else:
self.logger.info('[%s:%s] Response received %s',
response.status_code, response.reason,
response.url)
result = response.json()
if result['status'] != 'ok':
self.logger.error('Received response with status %s',
result['status'], extra={'response': result})
return False
self.logger.info('Sent to ClickHouse successfully')
return True
if __name__ == "__main__":
sentry_init()
logging.basicConfig(filename='stat_sender_standalone.log',
level=logging.INFO)
try:
StatisticsSender().send()
except SSAError as exc:
print(exc)
raise SystemExit(1)