Index: /branches/amp_4_0/src/webui/webui/htdocs/new/src/hive/db/slb_stats_queries.py
===================================================================
--- /branches/amp_4_0/src/webui/webui/htdocs/new/src/hive/db/slb_stats_queries.py (revision 2741)
+++ /branches/amp_4_0/src/webui/webui/htdocs/new/src/hive/db/slb_stats_queries.py (working copy)
@@ -9,9 +9,9 @@
pass
@staticmethod
- def get_virtual_service_stats(agent_host=None):
+ def get_virtual_service_stats(agent_host=None, time_from=None, time_to=None):
"""
- Fetch latest virtual service stats from apv_virtual_stats
+ Fetch virtual service stats from apv_virtual_stats within the given time range.
"""
base_query = """
WITH stats AS (
@@ -36,8 +36,9 @@
COALESCE(in_byte_per_sec, 0) AS in_byte_per_sec,
COALESCE(out_byte_per_sec, 0) AS out_byte_per_sec
FROM apv_virtual_stats
- WHERE time > now() - interval '20 seconds'
+ WHERE 1=1
{agent_host_filter}
+ {time_filter}
)
SELECT
COALESCE(MAX(total_hits) - MIN(total_hits), 0) AS hits_diff,
@@ -55,18 +56,30 @@
"""
agent_host_filter = "AND agent_host ~ %s" if agent_host else ""
- query = base_query.format(agent_host_filter=agent_host_filter)
+ time_filter = ""
+ params = []
- params = [agent_host] if agent_host else []
+ if agent_host:
+ params.append(agent_host)
+ if time_from and time_to:
+ time_filter = f"AND time >= '{time_from}' AND time <= '{time_to}'"
+ elif time_from:
+ time_filter = f"AND time >= '{time_from}'"
+ elif time_to:
+ time_filter = f"AND time <= '{time_to}'"
+ else:
+ time_filter = "AND time > now() - interval '20 seconds'"
+
+ query = base_query.format(agent_host_filter=agent_host_filter, time_filter=time_filter)
+
response = DBClient.execute_query({"query": query, "params": params})
field_casts = {
- "hits_diff": int,
+ "total_hits": int,
"last_conn_cnt": int,
"last_in": float,
- "last_out": float,
- "port": int
+ "last_out": float
}
response["data"] = cast_fields(response["data"], field_casts)
return response
@@ -276,11 +289,181 @@
field_casts = {
"connections": int
+ }
+ response["data"] = cast_fields(response["data"], field_casts)
+ return response
+
+ @staticmethod
+ def get_virtual_service_summary_data(agent_host, virtual_server_id, time_from, time_to):
+ """
+ Returns SLB Virtual Service summary stats aggregated over the full time range
+ for the given agent_host and virtual_server_id.
+ """
+ query = f"""
+ SELECT
+ agent_host,
+ "serverid" AS vs_name,
+ addr,
+ port,
+ protocol,
+ COALESCE(CAST(AVG(conn_cnt) AS bigint), 0) AS avg_conn_cnt,
+ COALESCE(CAST(AVG(conn_per_sec) AS bigint), 0) AS avg_conn_per_sec,
+ COALESCE(ROUND(CAST(AVG(in_byte_per_sec * 8) AS numeric), 2), 0) AS avg_in_byte_per_sec,
+ COALESCE(ROUND(CAST(AVG(out_byte_per_sec * 8) AS numeric), 2), 0) AS avg_out_byte_per_sec,
+ COALESCE(
+ ROUND(
+ CAST(
+ (
+ MAX(
+ url_hits + hostname_hits + perstnt_cookie_hits + qos_cookie_hits +
+ default_hits + perstnt_url_hits + static_hits + qos_network_hits +
+ qos_url_hits + backup_hits + cache_hits + regex_hits +
+ rcookie_hits + icookie_hits + qos_client_port_hits +
+ qos_body_hits + header_hits + hash_url_hits + redirect_hits
+ ) -
+ MIN(
+ url_hits + hostname_hits + perstnt_cookie_hits + qos_cookie_hits +
+ default_hits + perstnt_url_hits + static_hits + qos_network_hits +
+ qos_url_hits + backup_hits + cache_hits + regex_hits +
+ rcookie_hits + icookie_hits + qos_client_port_hits +
+ qos_body_hits + header_hits + hash_url_hits + redirect_hits
+ )
+ ) / EXTRACT(EPOCH FROM (MAX(time) - MIN(time)))
+ AS numeric), 2), 0
+ ) AS avg_hits_per_sec
+ FROM apv_virtual_stats
+ WHERE
+ agent_host = '{agent_host}'
+ AND "serverid" = '{virtual_server_id}'
+ AND time >= {time_from}
+ AND time <= {time_to}
+ GROUP BY
+ agent_host, "serverid", addr, port, protocol
+ ORDER BY "serverid";
+ """
+
+ req = {"query": query}
+ response = DBClient.execute_query(req)
+
+ field_casts = {
+ "avg_conn_cnt": float,
+ "avg_conn_per_sec": float,
+ "avg_in_byte_per_sec": float,
+ "avg_out_byte_per_sec": float,
+ "avg_hits_per_sec": float
}
response["data"] = cast_fields(response["data"], field_casts)
return response
@staticmethod
+ def get_virtual_service_historical_data(agent_host, virtual_server_id, interval, time_from, time_to):
+ """
+ Returns historical Virtual Service stats aggregated over time buckets.
+ Includes:
+ - Throughput (in/out)
+ - Connection count and connections/sec
+ - Total hits (delta)
+ - Per-hit-type distribution
+ """
+
+ query = f"""
+ SELECT
+ time_bucket_gapfill('{interval}', time, {time_from}, {time_to}) AS ts,
+ agent_host,
+ "serverid" AS vs_name,
+
+ -- Bandwidth (Bytes/sec)
+ COALESCE(AVG(in_byte_per_sec), 0) AS avg_in_byte_per_sec,
+ COALESCE(AVG(out_byte_per_sec), 0) AS avg_out_byte_per_sec,
+
+ -- Connections
+ COALESCE(AVG(conn_cnt), 0) AS avg_conn_cnt,
+ COALESCE(AVG(conn_per_sec), 0) AS avg_conn_per_sec,
+
+ -- Total Hits (aggregate of all types)
+ COALESCE(
+ MAX(
+ url_hits + hostname_hits + perstnt_cookie_hits + qos_cookie_hits +
+ default_hits + perstnt_url_hits + static_hits + qos_network_hits +
+ qos_url_hits + backup_hits + cache_hits + regex_hits +
+ rcookie_hits + icookie_hits + qos_client_port_hits +
+ qos_body_hits + header_hits + hash_url_hits + redirect_hits
+ ) -
+ MIN(
+ url_hits + hostname_hits + perstnt_cookie_hits + qos_cookie_hits +
+ default_hits + perstnt_url_hits + static_hits + qos_network_hits +
+ qos_url_hits + backup_hits + cache_hits + regex_hits +
+ rcookie_hits + icookie_hits + qos_client_port_hits +
+ qos_body_hits + header_hits + hash_url_hits + redirect_hits
+ ),
+ 0) AS hit_diff,
+
+ -- Individual hit types (delta per time bucket)
+ COALESCE(MAX(url_hits) - MIN(url_hits), 0) AS url_hits,
+ COALESCE(MAX(hostname_hits) - MIN(hostname_hits), 0) AS hostname_hits,
+ COALESCE(MAX(qos_cookie_hits) - MIN(qos_cookie_hits), 0) AS qos_cookie_hits,
+ COALESCE(MAX(qos_network_hits) - MIN(qos_network_hits), 0) AS qos_network_hits,
+ COALESCE(MAX(qos_url_hits) - MIN(qos_url_hits), 0) AS qos_url_hits,
+ COALESCE(MAX(qos_client_port_hits) - MIN(qos_client_port_hits), 0) AS qos_client_port_hits,
+ COALESCE(MAX(qos_body_hits) - MIN(qos_body_hits), 0) AS qos_body_hits,
+ COALESCE(MAX(perstnt_cookie_hits) - MIN(perstnt_cookie_hits), 0) AS perstnt_cookie_hits,
+ COALESCE(MAX(default_hits) - MIN(default_hits), 0) AS default_hits,
+ COALESCE(MAX(perstnt_url_hits) - MIN(perstnt_url_hits), 0) AS perstnt_url_hits,
+ COALESCE(MAX(static_hits) - MIN(static_hits), 0) AS static_hits,
+ COALESCE(MAX(backup_hits) - MIN(backup_hits), 0) AS backup_hits,
+ COALESCE(MAX(cache_hits) - MIN(cache_hits), 0) AS cache_hits,
+ COALESCE(MAX(regex_hits) - MIN(regex_hits), 0) AS regex_hits,
+ COALESCE(MAX(rcookie_hits) - MIN(rcookie_hits), 0) AS rcookie_hits,
+ COALESCE(MAX(icookie_hits) - MIN(icookie_hits), 0) AS icookie_hits,
+ COALESCE(MAX(header_hits) - MIN(header_hits), 0) AS header_hits,
+ COALESCE(MAX(hash_url_hits) - MIN(hash_url_hits), 0) AS hash_url_hits,
+ COALESCE(MAX(redirect_hits) - MIN(redirect_hits), 0) AS redirect_hits
+
+ FROM apv_virtual_stats
+ WHERE agent_host ~ %s
+ AND serverid ~ %s
+ AND time >= {time_from}
+ AND time <= {time_to}
+ GROUP BY ts, agent_host, serverid
+ ORDER BY ts ASC;
+ """
+
+ params = [agent_host, virtual_server_id]
+ req = {"query": query, "params": params}
+ response = DBClient.execute_query(req)
+
+ # Cast numeric fields properly
+ field_casts = {
+ "avg_in_byte_per_sec": float,
+ "avg_out_byte_per_sec": float,
+ "avg_conn_cnt": int,
+ "avg_conn_per_sec": float,
+ "hit_diff": int,
+ "url_hits": int,
+ "hostname_hits": int,
+ "qos_cookie_hits": int,
+ "qos_network_hits": int,
+ "qos_url_hits": int,
+ "qos_client_port_hits": int,
+ "qos_body_hits": int,
+ "perstnt_cookie_hits": int,
+ "default_hits": int,
+ "perstnt_url_hits": int,
+ "static_hits": int,
+ "backup_hits": int,
+ "cache_hits": int,
+ "regex_hits": int,
+ "rcookie_hits": int,
+ "icookie_hits": int,
+ "header_hits": int,
+ "hash_url_hits": int,
+ "redirect_hits": int
+ }
+
+ response["data"] = cast_fields(response["data"], field_casts)
+ return response
+
+ @staticmethod
def get_real_service_stats(agent_host):
"""
Fetch real service stats from apv_real_stats (TimescaleDB).
@@ -502,4 +685,4 @@
"connections": int
}
response["data"] = cast_fields(response["data"], field_casts)
- return response
\ No newline at end of file
+ return response
Index: /branches/amp_4_0/src/webui/webui/htdocs/new/src/hive/report/generate_pdf_report.py
===================================================================
--- /branches/amp_4_0/src/webui/webui/htdocs/new/src/hive/report/generate_pdf_report.py (revision 2741)
+++ /branches/amp_4_0/src/webui/webui/htdocs/new/src/hive/report/generate_pdf_report.py (working copy)
@@ -4,11 +4,33 @@
from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
from reportlab.lib.units import inch
from reportlab.platypus import SimpleDocTemplate, Table, TableStyle, Paragraph, Spacer, Image
+from hive.utils import andebug
from cm.lib.libbasic_operation import oper_log
REPORT_FILE_PATH = "/ca/webui/htdocs/new/src/hive/media/docs/"
LOGO_PATH = "/ca/webui/htdocs/new/src/hive/media/static/Array-Logo-en-2024.jpg"
+HIT_FIELD_MAP = {
+ "redirect_hits": "RedirectHits",
+ "qos_cookie_hits": "QosCookieHits",
+ "default_hits": "DefaultHits",
+ "perstnt_url_hits": "PerstntURLHits",
+ "cache_hits": "CacheHits",
+ "regex_hits": "RegexHits",
+ "url_hits": "URLHits",
+ "qos_client_port_hits": "QosClientPortHits",
+ "static_hits": "StaticHits",
+ "qos_url_hits": "QosURLHits",
+ "hostname_hits": "HostnameHits",
+ "rcookie_hits": "RCookieHits",
+ "perstnt_cookie_hits": "PerstntCookieHits",
+ "hash_url_hits": "HashURLHits",
+ "icookie_hits": "ICookieHits",
+ "qos_body_hits": "QosBodyHits",
+ "backup_hits": "BackupHits",
+ "qos_network_hits": "QosNetworkHits",
+ "header_hits": "HeaderHits",
+}
class Report:
@@ -16,116 +38,145 @@
def __init__(self):
pass
- def get_table_data(self, headers, llb_data):
- # Add Table Data
- data = [tuple(headers)] + llb_data
- table = Table(data, colWidths=int(480 / len(headers)), rowHeights=20)
- data_len = len(data)
-
- for each in range(data_len):
- if each == 0:
- bg_color = colors.lightgrey
- else:
- bg_color = colors.white
-
- table.setStyle(TableStyle([('BACKGROUND', (0, each), (-1, each), bg_color),
- ('FONT', (0, 0), (-1, -1), 'Helvetica'), ]))
- return table
-
- def generate_pdf_report(self, filename, category, llb_data_dict, link_data_summary_dict, start_time, end_time):
+ def generate_pdf_report(self, filename, category, data_dict, data_summary_dict, start_time, end_time):
+ """
+ Generate a PDF report for LLB, SLB, or any other category dynamically.
+ """
try:
- """
- Generate a PDF report with a table and an optional chart.
- """
os.makedirs(REPORT_FILE_PATH, exist_ok=True)
pdf = SimpleDocTemplate(REPORT_FILE_PATH + filename, pagesize=letter)
elements = []
styles = getSampleStyleSheet()
- styles.add(ParagraphStyle(
- name="LLBHeading3",
- parent=styles["Heading3"],
- leftPadding=0 # Add spacing before the paragraph
- ))
+ styles.add(ParagraphStyle(name="AMPReportHeading3", parent=styles["Heading3"], leftPadding=0))
+ # Header
im = Image(LOGO_PATH, 2 * inch, 0.8 * inch)
im.hAlign = 'CENTER'
- elements.append(im)
- elements.append(Spacer(1, 20))
+ elements += [im, Spacer(1, 20)]
- # Add Title & Subtitle
- category_name = str(category).upper()
- title = category_name + " Report"
- elements.append(Paragraph('{}'.format(title), styles["Title"]))
- elements.append(Spacer(1, 20))
+ # Title
+ if "vs" in category:
+ category_name = "SLB Virtual Service"
+ elif "rs" in category:
+ category_name = "SLB Real Service"
+ else:
+ category_name = str(category).upper()
- elements.append(Paragraph("Statistics From" + " : " + str(start_time), styles["Heading4"]))
- elements.append(Paragraph("Statistics To" + " : " + str(end_time), styles["Heading4"]))
+ title = f"{category_name} Report"
+ elements.append(Paragraph(f"{title}", styles["Title"]))
+ elements += [Spacer(1, 20)]
+ elements.append(Paragraph(f"Statistics From : {start_time}", styles["Heading4"]))
+ elements.append(Paragraph(f"Statistics To : {end_time}", styles["Heading4"]))
elements.append(Spacer(1, 10))
- # Summary report
- if link_data_summary_dict:
- elements.append(Paragraph("Summary Report (Average values)" + " :", styles["LLBHeading3"]))
- for link in link_data_summary_dict:
- data = link_data_summary_dict.get(link)
- elements.append(Spacer(1, 20))
- headers = ["Link Name", "Hits", "Connections", "Inbound (bps)", "Outbound (bps)", "Bandwidth Usage"]
- link_data = [str(link), data["avg_link_hits"], data["avg_link_conn"], data["avg_bandwidth_in"],
- data["avg_bandwidth_out"], data["avg_link_usage"]]
- table = self.get_table_data(headers, [link_data])
- elements.append(table)
- elements.append(Spacer(1, 30))
+ # --- Summary Section ---
+ if data_summary_dict:
+ elements.append(Paragraph("Summary Report (Average values):", styles["AMPReportHeading3"]))
+ summary_headers, summary_fields = self.get_summary_headers_and_fields(category)
+ for entity_name, summary_data in data_summary_dict.items():
+ row_values = [str(entity_name)] + [summary_data.get(field, 0) for field in summary_fields]
+ table = self.get_table_data(summary_headers, [row_values])
+ elements += [Spacer(1, 15), table, Spacer(1, 25)]
- # Detailed Report
- if llb_data_dict:
- elements.append(Paragraph("Detailed Report" + " :", styles["LLBHeading3"]))
- for each_link in llb_data_dict:
- elements.append(Paragraph("Link: " + each_link, styles["Heading3"]))
- elements.append(Spacer(1, 20))
+ # --- Detailed Section ---
+ if data_dict:
+ elements.append(Paragraph("Detailed Report:", styles["AMPReportHeading3"]))
+ section_config = self.get_detailed_sections(category)
- llb_link_data = llb_data_dict.get(each_link)
+ for entity_name, metrics in data_dict.items():
+ elements.append(Paragraph(f"Virtual Service Name: {str(entity_name)}", styles["Heading3"]))
+ elements.append(Spacer(1, 15))
- elements.append(Paragraph("Link Throughput(bps)", styles["Heading4"]))
- elements.append(Spacer(1, 20))
- # Clean up timezone info in time strings
- formatted_time = [
- str(t).split('+')[0] if isinstance(t, str) else t.strftime("%Y-%m-%d %H:%M:%S")
- for t in llb_link_data["time"]
- ]
- headers = ["Time", "Inbound (bps)", "Outbound (bps)"]
- llb_data = list(
- zip(formatted_time, llb_link_data["inbound_list"], llb_link_data["outbound_list"]))
- table = self.get_table_data(headers, llb_data)
- elements.append(table)
- elements.append(Spacer(1, 30))
+ # Render each subsection (e.g., throughput, usage, hits)
+ for section in section_config:
+ title = section["title"]
+ headers = section["headers"]
+ fields = section["fields"]
- elements.append(Paragraph("Bandwidth Usage", styles["Heading4"]))
- elements.append(Spacer(1, 20))
- headers = ["Time", "Bandwidth Usage"]
- llb_data = list(
- zip(llb_link_data["time"], llb_link_data["bandwidth_usage_list"]))
- table = self.get_table_data(headers, llb_data)
- elements.append(table)
- elements.append(Spacer(1, 30))
+ if title == 'Hits Distribution':
+ elements.append(Paragraph("Hits Distribution", styles["Heading4"]))
+ elements.append(Spacer(1, 10))
- elements.append(Paragraph("Concurrent Connections", styles["Heading4"]))
- elements.append(Spacer(1, 20))
- headers = ["Time", "Concurrent Connections"]
- llb_data = list(
- zip(llb_link_data["time"], llb_link_data["cc_list"]))
- table = self.get_table_data(headers, llb_data)
- elements.append(table)
- elements.append(Spacer(1, 30))
+ # Prepare data as [(hit_type, total), ...]
+ hits_distribution = []
+ for db_field, display_name in HIT_FIELD_MAP.items():
+ values = metrics.get(db_field, [])
+ total = sum(v for v in values if isinstance(v, (int, float)))
+ hits_distribution.append((display_name, total))
- elements.append(Paragraph("Hits", styles["Heading4"]))
- elements.append(Spacer(1, 20))
- headers = ["Time", "Hits"]
- llb_data = list(
- zip(llb_link_data["time"], llb_link_data["hit_list"]))
- table = self.get_table_data(headers, llb_data)
- elements.append(table)
- elements.append(Spacer(1, 30))
+ table_data = [(hit_name, total) for hit_name, total in hits_distribution]
+ table = self.get_table_data(["Hit Type", "Number"], table_data)
+ elements += [table, Spacer(1, 25)]
+ else:
+ elements.append(Paragraph(title, styles["Heading4"]))
+ elements.append(Spacer(1, 10))
+ # Clean time format
+ formatted_time = [
+ str(t).split('+')[0] if isinstance(t, str) else t.strftime("%Y-%m-%d %H:%M:%S")
+ for t in metrics["time"]
+ ]
+
+ table_data = list(zip(formatted_time, *[metrics.get(field, []) for field in fields]))
+ table = self.get_table_data(headers, table_data)
+ elements += [table, Spacer(1, 25)]
+
pdf.build(elements)
+
except Exception as e:
oper_log('error', 'system', str(e))
- raise e # Raise to crash and see error
+ raise e
+
+ def get_table_data(self, headers, data):
+ # Add Table Data
+ data = [tuple(headers)] + data
+ table = Table(data, colWidths=int(480 / len(headers)), rowHeights=20)
+ data_len = len(data)
+
+ for each in range(data_len):
+ if each == 0:
+ bg_color = colors.lightgrey
+ else:
+ bg_color = colors.white
+
+ table.setStyle(TableStyle([('BACKGROUND', (0, each), (-1, each), bg_color),
+ ('FONT', (0, 0), (-1, -1), 'Helvetica'), ]))
+ return table
+
+ def get_summary_headers_and_fields(self, category):
+ """Return headers and data field keys based on report type."""
+ if "llb" in category.lower():
+ return (
+ ["Link Name", "Hits", "Connections", "Inbound (bps)", "Outbound (bps)", "Bandwidth Usage"],
+ ["avg_link_hits", "avg_link_conn", "avg_bandwidth_in", "avg_bandwidth_out", "avg_link_usage"]
+ )
+ elif "vs" in category.lower():
+ return (
+ ["Virtual Service", "Conn Count", "Conn/sec", "Inbound (bps)", "Outbound (bps)", "Hits"],
+ ["avg_conn_cnt", "avg_conn_per_sec", "avg_in_byte_per_sec", "avg_out_byte_per_sec",
+ "avg_hits_per_sec"]
+ )
+ else:
+ return ["Entity", "Metric1", "Metric2"], ["metric1", "metric2"] # placeholder for future types
+
+ def get_detailed_sections(self, category):
+ """Return detailed table configuration per category."""
+ if "llb" in category.lower():
+ return [
+ {"title": "Link Throughput (bps)", "headers": ["Time", "Inbound (bps)", "Outbound (bps)"],
+ "fields": ["inbound_list", "outbound_list"]},
+ {"title": "Bandwidth Usage", "headers": ["Time", "Usage"], "fields": ["bandwidth_usage_list"]},
+ {"title": "Concurrent Connections", "headers": ["Time", "Connections"], "fields": ["cc_list"]},
+ {"title": "Hits", "headers": ["Time", "Hits"], "fields": ["hit_list"]},
+ ]
+ elif "vs" in category.lower():
+ return [
+ {"title": "Network Throughput (bps)", "headers": ["Time", "Inbound (bps)", "Outbound (bps)"],
+ "fields": ["avg_in_byte_per_sec", "avg_out_byte_per_sec"]},
+ {"title": "Hits", "headers": ["Time", "Hits"], "fields": ["hit_diff"]},
+ {"title": "Hits Distribution", "headers": ["Hit Type", "Number"], "fields": ["hit_diff"]},
+ {"title": "Open Connections", "headers": ["Time", "Connection"], "fields": ["avg_conn_cnt"]},
+ {"title": "Connections Per Second", "headers": ["Time", "Connection"], "fields": ["avg_conn_per_sec"]},
+ ]
+ else:
+ return []
Index: /branches/amp_4_0/src/webui/webui/htdocs/new/src/hive/report/generate_report.py
===================================================================
--- /branches/amp_4_0/src/webui/webui/htdocs/new/src/hive/report/generate_report.py (revision 2741)
+++ /branches/amp_4_0/src/webui/webui/htdocs/new/src/hive/report/generate_report.py (working copy)
@@ -1,13 +1,13 @@
import json
import os
import time
-from datetime import datetime
from django.http import JsonResponse, StreamingHttpResponse
+from hive.report.report_utils import get_dynamic_interval, to_epoch_ms, convert_relative_time, resolve_time_ranges
+from hive.report.report_data_service import get_llb_detailed_data, get_link_summary_data, \
+ get_virtual_service_detailed_data, get_virtual_service_summary_data
from cm.lib.libbasic_operation import oper_log
from hive.custom_exceptions import generic_exception as ge
-from hive.db.llb_stats_queries import LLBStatsDB
from hive.report.report_queries import ReportDB
-from hive.services.utils import convert_time
from hive.report.generate_pdf_report import Report
from hive.utils import andebug
@@ -15,7 +15,6 @@
def handle_report_generation(request, path=None, report_id=None):
- andebug('an.model.cli', 'Inside handle_report_generation')
try:
if request.method == 'POST':
if path == 'save':
@@ -24,12 +23,13 @@
return generate_report(request, report_id)
elif request.method == 'PUT' and report_id:
- andebug('an.model.cli', 'Inside update_report else')
return update_report(request, report_id)
elif request.method == 'GET':
if path == 'download':
return download_report(request.GET.get('filename'))
+ elif path == 'log':
+ return get_all_report_log(request)
else:
return get_all_reports(request)
@@ -61,6 +61,22 @@
return JsonResponse({"error": f"Unexpected error: {str(e)}"}, status=500)
+def get_all_report_log(request):
+ """
+ Handle GET request to fetch all report logs.
+ """
+ try:
+ if request.method != 'GET':
+ return JsonResponse({"error": "Invalid request method"}, status=405)
+
+ report_logs = ReportDB.get_all_report_log()
+
+ return JsonResponse({"report logs": report_logs}, status=200, safe=False)
+ except Exception as e:
+ oper_log("error", "system", f"Unexpected error in get_all_report_log: {str(e)}")
+ return JsonResponse({"error": f"Unexpected error: {str(e)}"}, status=500)
+
+
def save_report(request):
""" Save New Report """
try:
@@ -198,192 +214,78 @@
# Insert a new report_log entry
log_response = ReportDB.insert_report_log(report_id, report["subject_type"], report["subject_name"])
log_id = log_response[0]["id"] if isinstance(log_response, list) else log_response
+ from_time = report.get("from_time")
+ to_time = report.get("to_time")
+ time_interval = get_dynamic_interval(from_time, to_time)
if report.get("subject_type") == "service_status":
sub_name = report.get("subject_name", "")
if "LLB" in sub_name:
- from_time = report.get("from_time")
- to_time = report.get("to_time")
- time_interval = get_dynamic_interval(from_time, to_time)
+ report_name = generate_llb_report(report, from_time, to_time, time_interval)
+ elif "SLB_vs" in sub_name:
+ agent_host = report.get("device_ip", "")
+ vs_name = sub_name.split("(")[0].strip()
+ report_name = generate_slb_vs_report(agent_host, vs_name, from_time, to_time, time_interval)
- data_dict = get_llb_detailed_data_for_report(from_time, to_time, None, time_interval)
- data_summary_dict = get_link_summary_data_for_report(from_time, to_time)
+ file_path = os.path.join(REPORT_FILE_PATH, report_name)
+ file_size = os.path.getsize(file_path) if os.path.exists(file_path) else 0
+ status = 1 if os.path.exists(file_path) else 0
+ ReportDB.update_report_log(report_id, status, report_name, file_size)
+ ReportDB.update_report_status(status, report_id)
+ if status:
+ return JsonResponse(
+ {
+ "message": "Report generated successfully",
+ "report_id": report_id,
+ "log_id": log_id,
+ "file_name": report_name,
+ "file_size": file_size,
+ },
+ status=200 if status else 500,
+ )
+ else:
+ return JsonResponse({"error": "Report generation failed"}, status=500)
+ else:
+ return JsonResponse({"error": f"Unsupported report type: {report.get('subject_type')}"}, status=400)
- if isinstance(from_time, str) and from_time.startswith("now"):
- if "-" in from_time: # e.g., now-15m, now-1h
- interval_start = _convert_relative_time(from_time)
- else:
- interval_start = int(time.time() * 1000) # plain 'now'
- interval_end = int(time.time() * 1000)
- else:
- interval_start = _to_epoch_ms(from_time)
- interval_end = _to_epoch_ms(to_time)
- filename_start_time_str = time.strftime("%Y_%m_%d_%H_%M_%S", time.localtime(interval_start / 1000))
- filename_end_time_str = time.strftime("%Y_%m_%d_%H_%M_%S", time.localtime(interval_end / 1000))
+def generate_llb_report(report, from_time, to_time, time_interval):
+ data_dict = get_llb_detailed_data(from_time, to_time, None, time_interval)
+ data_summary_dict = get_link_summary_data(from_time, to_time)
- display_start_time_str = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(interval_start / 1000))
- display_end_time_str = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(interval_end / 1000))
+ (
+ interval_start,
+ interval_end,
+ filename_start_time_str,
+ filename_end_time_str,
+ display_start_time_str,
+ display_end_time_str,
+ ) = resolve_time_ranges(from_time, to_time)
- report_name = f"LLB_Statistics_Report_from_{filename_start_time_str}_to_{filename_end_time_str}.pdf"
+ report_name = f"LLB_Statistics_Report_from_{filename_start_time_str}_to_{filename_end_time_str}.pdf"
+ report_generator = Report()
+ report_generator.generate_pdf_report(
+ report_name, "LLB", data_dict, data_summary_dict, display_start_time_str, display_end_time_str
+ )
+ return report_name
- report_generator = Report()
- report_generator.generate_pdf_report(
- report_name, "LLB", data_dict, data_summary_dict, display_start_time_str, display_end_time_str
- )
- file_path = os.path.join(REPORT_FILE_PATH, report_name)
- file_size = os.path.getsize(file_path) if os.path.exists(file_path) else 0
- status = 1 if os.path.exists(file_path) else 0
+def generate_slb_vs_report(agent_host, vs_name, from_time, to_time, time_interval):
+ data_dict = get_virtual_service_detailed_data(agent_host, vs_name, from_time, to_time, time_interval)
+ data_summary_dict = get_virtual_service_summary_data(agent_host, vs_name, from_time, to_time)
- # Update DB
- ReportDB.update_report_log(report_id, status, report_name, file_size)
- ReportDB.update_report_status(status, report_id)
+ (
+ interval_start,
+ interval_end,
+ filename_start_time_str,
+ filename_end_time_str,
+ display_start_time_str,
+ display_end_time_str,
+ ) = resolve_time_ranges(from_time, to_time)
- if status:
- return JsonResponse(
- {
- "message": "Report generated successfully",
- "report_id": report_id,
- "log_id": log_id,
- "file_name": report_name,
- "file_size": file_size,
- },
- status=200 if status else 500,
- )
- else:
- return JsonResponse({"error": "Report generation failed"}, status=500)
- else:
- return JsonResponse({"error": f"Unsupported report type: {report.get('subject_type')}"}, status=400)
-
-
-def get_dynamic_interval(from_time, to_time):
- """
- Determine optimal interval size for querying time-series data,
- based on the total range between from_time and to_time.
- """
- try:
- # Convert string timestamps (ISO 8601 or epoch) to integers (milliseconds)
- if isinstance(from_time, str) and from_time.startswith("now"):
- if "-" in from_time: # e.g., now-15m, now-1h
- from_time_ms = _convert_relative_time(from_time)
- else:
- from_time_ms = int(time.time() * 1000) # plain 'now'
- to_time_ms = int(time.time() * 1000)
- else:
- from_time_ms = _to_epoch_ms(from_time)
- to_time_ms = _to_epoch_ms(to_time)
-
- diff_ms = abs(to_time_ms - from_time_ms)
- diff_hours = diff_ms / (1000 * 60 * 60)
-
- # Decide on interval granularity based on time range
- if diff_hours <= 6:
- return "1m" # up to 6 hours → 1-minute resolution
- elif diff_hours <= 24:
- return "5m" # 6–24 hours → 5-minute resolution
- elif diff_hours <= 72:
- return "15m" # 1–3 days → 15-minute resolution
- elif diff_hours <= 168:
- return "1h" # up to 1 week → 1-hour resolution
- elif diff_hours <= 720:
- return "6h" # up to 1 month → 6-hour resolution
- else:
- return "1d" # over a month → daily resolution
-
- except Exception as e:
- oper_log('error', 'system', f"Error computing interval: {str(e)}")
- return "20s" # fallback
-
-
-def _to_epoch_ms(value):
- """Convert ISO 8601 string or epoch (sec/ms) to milliseconds"""
- if isinstance(value, (int, float)):
- return int(value if value > 1e12 else value * 1000)
- elif isinstance(value, str):
- try:
- return int(datetime.fromisoformat(value.replace("Z", "+00:00")).timestamp() * 1000)
- except Exception:
- return int(value) # fallback if numeric string
- return int(time.time() * 1000)
-
-
-def _convert_relative_time(value):
- """Handle 'now-10m', 'now-1h', etc."""
- units = {"m": 60 * 1000, "h": 3600 * 1000, "d": 86400 * 1000}
- if not value.startswith("now"):
- return int(time.time() * 1000)
- num = int(''.join([c for c in value if c.isdigit()]))
- unit = ''.join([c for c in value if c.isalpha()])[-1]
- return int(time.time() * 1000) - (num * units.get(unit, 0))
-
-
-def get_link_summary_data_for_report(time_from, time_to):
- """ Returns data for LLB Summary Report """
- try:
- from_time = convert_time(time_from, "now() - interval '15 minutes'")
- to_time = convert_time(time_to, "now()")
- response = LLBStatsDB.get_llb_summary_data(from_time, to_time)
-
- if not response or "data" not in response:
- return {}
-
- summary_dict = {}
- for row in response["data"]:
- link_name = row.get("link_name")
- summary_dict[link_name] = {
- "avg_link_hits": row.get("avg_link_hits", 0),
- "avg_link_conn": row.get("avg_link_conn", 0),
- "avg_bandwidth_in": row.get("avg_bandwid_in", 0),
- "avg_bandwidth_out": row.get("avg_bandwid_out", 0),
- "avg_link_usage": row.get("avg_link_usage", 0)
- }
-
- return summary_dict
-
- except Exception as e:
- return JsonResponse({"error": f"Error while fetching LLB data: {str(e)}"}, status=500)
-
-
-def get_llb_detailed_data_for_report(time_from, time_to, link_name=None, interval="20s"):
- """ Returns data for LLB Detailed report. """
- try:
- from_time = convert_time(time_from, "now() - interval '15 minutes'")
- to_time = convert_time(time_to, "now()")
- response = LLBStatsDB.get_llb_historical_data(from_time, to_time, link_name, interval)
-
- # Defensive check
- if not response or "data" not in response or not isinstance(response["data"], list):
- return {}
-
- llb_dict = {}
-
- for row in response["data"]:
- link = row.get("link_name", "unknown")
- ts = row.get("ts")
- if not ts:
- continue # Skip incomplete rows
-
- # Initialize dict for link_name
- if link not in llb_dict:
- llb_dict[link] = {
- "time": [],
- "inbound_list": [],
- "outbound_list": [],
- "bandwidth_usage_list": [],
- "cc_list": [],
- "hit_list": []
- }
-
- # Append metrics to each list
- llb_dict[link]["time"].append(ts)
- llb_dict[link]["inbound_list"].append(row.get("avg_bandwid_in", 0))
- llb_dict[link]["outbound_list"].append(row.get("avg_bandwid_out", 0))
- llb_dict[link]["bandwidth_usage_list"].append(row.get("avg_link_usage", 0))
- llb_dict[link]["cc_list"].append(row.get("avg_link_conn", 0))
- llb_dict[link]["hit_list"].append(row.get("avg_link_hits", 0))
-
- return llb_dict
-
- except Exception as e:
- return JsonResponse({"error": f"Error while fetching LLB data: {str(e)}"}, status=500)
+ report_name = f"SLB_VS_Statistics_Report_from_{filename_start_time_str}_to_{filename_end_time_str}.pdf"
+ report_generator = Report()
+ report_generator.generate_pdf_report(
+ report_name, "SLB_vs", data_dict, data_summary_dict, display_start_time_str, display_end_time_str
+ )
+ return report_name
Index: /branches/amp_4_0/src/webui/webui/htdocs/new/src/hive/report/report_data_service.py
===================================================================
--- /branches/amp_4_0/src/webui/webui/htdocs/new/src/hive/report/report_data_service.py (nonexistent)
+++ /branches/amp_4_0/src/webui/webui/htdocs/new/src/hive/report/report_data_service.py (working copy)
@@ -0,0 +1,153 @@
+from hive.services.utils import convert_time
+from hive.db.llb_stats_queries import LLBStatsDB
+from hive.db.slb_stats_queries import SLBStats
+from django.http import JsonResponse
+from hive.utils import andebug
+
+
+def get_link_summary_data(time_from, time_to):
+ """ Returns data for LLB Summary Report """
+ try:
+ from_time = convert_time(time_from, "now() - interval '15 minutes'")
+ to_time = convert_time(time_to, "now()")
+ response = LLBStatsDB.get_llb_summary_data(from_time, to_time)
+
+ if not response or "data" not in response:
+ return {}
+
+ summary_dict = {}
+ for row in response["data"]:
+ link_name = row.get("link_name")
+ summary_dict[link_name] = {
+ "avg_link_hits": row.get("avg_link_hits", 0),
+ "avg_link_conn": row.get("avg_link_conn", 0),
+ "avg_bandwidth_in": row.get("avg_bandwid_in", 0),
+ "avg_bandwidth_out": row.get("avg_bandwid_out", 0),
+ "avg_link_usage": row.get("avg_link_usage", 0)
+ }
+
+ return summary_dict
+
+ except Exception as e:
+ return JsonResponse({"error": f"Error while fetching LLB data: {str(e)}"}, status=500)
+
+
+def get_llb_detailed_data(time_from, time_to, link_name=None, interval="20s"):
+ """ Returns data for LLB Detailed report. """
+ try:
+ from_time = convert_time(time_from, "now() - interval '15 minutes'")
+ to_time = convert_time(time_to, "now()")
+ response = LLBStatsDB.get_llb_historical_data(from_time, to_time, link_name, interval)
+
+ # Defensive check
+ if not response or "data" not in response or not isinstance(response["data"], list):
+ return {}
+
+ llb_dict = {}
+
+ for row in response["data"]:
+ link = row.get("link_name", "unknown")
+ ts = row.get("ts")
+ if not ts:
+ continue # Skip incomplete rows
+
+ # Initialize dict for link_name
+ if link not in llb_dict:
+ llb_dict[link] = {
+ "time": [],
+ "inbound_list": [],
+ "outbound_list": [],
+ "bandwidth_usage_list": [],
+ "cc_list": [],
+ "hit_list": []
+ }
+
+ # Append metrics to each list
+ llb_dict[link]["time"].append(ts)
+ llb_dict[link]["inbound_list"].append(row.get("avg_bandwid_in", 0))
+ llb_dict[link]["outbound_list"].append(row.get("avg_bandwid_out", 0))
+ llb_dict[link]["bandwidth_usage_list"].append(row.get("avg_link_usage", 0))
+ llb_dict[link]["cc_list"].append(row.get("avg_link_conn", 0))
+ llb_dict[link]["hit_list"].append(row.get("avg_link_hits", 0))
+
+ return llb_dict
+
+ except Exception as e:
+ return JsonResponse({"error": f"Error while fetching LLB data: {str(e)}"}, status=500)
+
+
+def get_virtual_service_summary_data(agent_host, vs_name, time_from, time_to):
+ """ Returns data for Virtual Service Summary Report """
+ try:
+ from_time = convert_time(time_from, "now() - interval '15 minutes'")
+ to_time = convert_time(time_to, "now()")
+ response = SLBStats.get_virtual_service_summary_data(agent_host, vs_name,from_time, to_time)
+
+ if not response or "data" not in response or not isinstance(response["data"], list):
+ return {}
+
+ summary_dict = {}
+ for row in response["data"]:
+ vs_name = row.get("vs_name")
+ summary_dict[vs_name] = {
+ "avg_conn_cnt": row.get("avg_conn_cnt", 0),
+ "avg_conn_per_sec": row.get("avg_conn_per_sec", 0),
+ "avg_in_byte_per_sec": row.get("avg_in_byte_per_sec", 0),
+ "avg_out_byte_per_sec": row.get("avg_out_byte_per_sec", 0),
+ "avg_hits_per_sec": row.get("avg_hits_per_sec", 0),
+ }
+
+ return summary_dict
+ except Exception as e:
+ return JsonResponse({"error": f"Error while fetching Virtual Service Summary data: {str(e)}"}, status=500)
+
+
+def get_virtual_service_detailed_data(agent_host, vs_name, time_from, time_to, interval="20s"):
+ """Returns detailed SLB Virtual Service statistics for report generation."""
+ try:
+ from_time = convert_time(time_from, "now() - interval '15 minutes'")
+ to_time = convert_time(time_to, "now()")
+
+ response = SLBStats.get_virtual_service_historical_data(agent_host, vs_name, interval, from_time, to_time)
+
+ # Defensive check
+ if not response or "data" not in response or not isinstance(response["data"], list):
+ return {}
+
+ slb_vs_dict = {}
+
+ # Define all fields we want to capture (except time)
+ metric_fields = [
+ "avg_in_byte_per_sec", "avg_out_byte_per_sec", "avg_conn_cnt", "avg_conn_per_sec", "hit_diff",
+ "url_hits", "hostname_hits", "qos_cookie_hits", "qos_network_hits",
+ "qos_url_hits", "qos_client_port_hits", "qos_body_hits", "perstnt_cookie_hits",
+ "default_hits", "perstnt_url_hits", "static_hits", "backup_hits",
+ "cache_hits", "regex_hits", "rcookie_hits", "icookie_hits",
+ "header_hits", "hash_url_hits", "redirect_hits"
+ ]
+
+ for row in response["data"]:
+ virtual_service = row.get("vs_name", "unknown")
+ ts = row.get("ts")
+ if not ts:
+ continue
+
+ if virtual_service not in slb_vs_dict:
+ # Initialize lists for all fields
+ slb_vs_dict[virtual_service] = {"time": []}
+ for field in metric_fields:
+ slb_vs_dict[virtual_service][field] = []
+
+ vs_data = slb_vs_dict[virtual_service]
+
+ # Append timestamp
+ vs_data["time"].append(ts)
+
+ # Append all metric fields dynamically
+ for field in metric_fields:
+ vs_data[field].append(row.get(field, 0))
+
+ return slb_vs_dict
+
+ except Exception as e:
+ return JsonResponse({"error": f"Error while fetching SLB Virtual Service data: {str(e)}"}, status=500)
\ No newline at end of file
Index: /branches/amp_4_0/src/webui/webui/htdocs/new/src/hive/report/report_queries.py
===================================================================
--- /branches/amp_4_0/src/webui/webui/htdocs/new/src/hive/report/report_queries.py (revision 2741)
+++ /branches/amp_4_0/src/webui/webui/htdocs/new/src/hive/report/report_queries.py (working copy)
@@ -142,7 +142,33 @@
else:
oper_log('error', 'system', f"Report {report_id} not found or already deleted or DB error")
return False
+
+ @staticmethod
+ def get_all_report_log():
+ """
+ Fetch report log entries by report_id.
+ """
+ query = f"""
+ SELECT
+ id,
+ subject_type,
+ subject_name,
+ start_time,
+ status,
+ result
+ FROM report_log;
+ """
+ req = {"query": query}
+ response = DBClient.execute_query(req, "postgres")
+ if response.get("status") == 200:
+ return response.get("data", [])
+ else:
+ oper_log('error', 'system',
+ f"Failed to fetch report_log: {response.get('message')} - {response.get('data')}")
+ return []
+
+
@staticmethod
def get_report_log(report_id):
"""
Index: /branches/amp_4_0/src/webui/webui/htdocs/new/src/hive/report/report_utils.py
===================================================================
--- /branches/amp_4_0/src/webui/webui/htdocs/new/src/hive/report/report_utils.py (nonexistent)
+++ /branches/amp_4_0/src/webui/webui/htdocs/new/src/hive/report/report_utils.py (working copy)
@@ -0,0 +1,101 @@
+import datetime
+import time
+from cm.lib.libbasic_operation import oper_log
+
+
+def get_dynamic_interval(from_time, to_time):
+ """
+ Determine optimal interval size for querying time-series data,
+ based on the total range between from_time and to_time.
+ """
+ try:
+ # Convert string timestamps (ISO 8601 or epoch) to integers (milliseconds)
+ if isinstance(from_time, str) and from_time.startswith("now"):
+ if "-" in from_time: # e.g., now-15m, now-1h
+ from_time_ms = convert_relative_time(from_time)
+ else:
+ from_time_ms = int(time.time() * 1000) # plain 'now'
+ to_time_ms = int(time.time() * 1000)
+ else:
+ from_time_ms = to_epoch_ms(from_time)
+ to_time_ms = to_epoch_ms(to_time)
+
+ diff_ms = abs(to_time_ms - from_time_ms)
+ diff_hours = diff_ms / (1000 * 60 * 60)
+
+ # Decide on interval granularity based on time range
+ if diff_hours <= 6:
+ return "1m" # up to 6 hours → 1-minute resolution
+ elif diff_hours <= 24:
+ return "5m" # 6–24 hours → 5-minute resolution
+ elif diff_hours <= 72:
+ return "15m" # 1–3 days → 15-minute resolution
+ elif diff_hours <= 168:
+ return "1h" # up to 1 week → 1-hour resolution
+ elif diff_hours <= 720:
+ return "6h" # up to 1 month → 6-hour resolution
+ else:
+ return "1d" # over a month → daily resolution
+
+ except Exception as e:
+ oper_log('error', 'system', f"Error computing interval: {str(e)}")
+ return "20s" # fallback
+
+
+def to_epoch_ms(value):
+ """Convert ISO 8601 string or epoch (sec/ms) to milliseconds"""
+ if isinstance(value, (int, float)):
+ return int(value if value > 1e12 else value * 1000)
+ elif isinstance(value, str):
+ try:
+ return int(datetime.fromisoformat(value.replace("Z", "+00:00")).timestamp() * 1000)
+ except Exception:
+ return int(value) # fallback if numeric string
+ return int(time.time() * 1000)
+
+
+def convert_relative_time(value):
+ """Handle 'now-10m', 'now-1h', etc."""
+ units = {"m": 60 * 1000, "h": 3600 * 1000, "d": 86400 * 1000}
+ if not value.startswith("now"):
+ return int(time.time() * 1000)
+ num = int(''.join([c for c in value if c.isdigit()]))
+ unit = ''.join([c for c in value if c.isalpha()])[-1]
+ return int(time.time() * 1000) - (num * units.get(unit, 0))
+
+
+def resolve_time_ranges(from_time, to_time):
+ """
+ Convert from_time and to_time (which may be relative like 'now-15m' or absolute)
+ into epoch milliseconds and formatted strings for filenames and display.
+ Returns:
+ interval_start (int): start time in epoch ms
+ interval_end (int): end time in epoch ms
+ filename_start_time_str (str)
+ filename_end_time_str (str)
+ display_start_time_str (str)
+ display_end_time_str (str)
+ """
+ if isinstance(from_time, str) and from_time.startswith("now"):
+ if "-" in from_time: # e.g., now-15m, now-1h
+ interval_start = convert_relative_time(from_time)
+ else:
+ interval_start = int(time.time() * 1000) # plain 'now'
+ interval_end = int(time.time() * 1000)
+ else:
+ interval_start = to_epoch_ms(from_time)
+ interval_end = to_epoch_ms(to_time)
+
+ filename_start_time_str = time.strftime("%Y_%m_%d_%H_%M_%S", time.localtime(interval_start / 1000))
+ filename_end_time_str = time.strftime("%Y_%m_%d_%H_%M_%S", time.localtime(interval_end / 1000))
+ display_start_time_str = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(interval_start / 1000))
+ display_end_time_str = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(interval_end / 1000))
+
+ return (
+ interval_start,
+ interval_end,
+ filename_start_time_str,
+ filename_end_time_str,
+ display_start_time_str,
+ display_end_time_str,
+ )
Index: /branches/amp_4_0/src/webui/webui/htdocs/new/src/hive/services/slb_stats_service.py
===================================================================
--- /branches/amp_4_0/src/webui/webui/htdocs/new/src/hive/services/slb_stats_service.py (revision 2741)
+++ /branches/amp_4_0/src/webui/webui/htdocs/new/src/hive/services/slb_stats_service.py (working copy)
@@ -18,7 +18,7 @@
elif req.get("stat_name") == "connections_per_sec":
response = SLBStats.get_connections_per_sec(agent_host, server_id, interval, time_from, time_to)
else:
- response = SLBStats.get_virtual_service_stats(agent_host)
+ response = SLBStats.get_virtual_service_stats(agent_host, time_from, time_from)
return response
\ No newline at end of file