Index: /branches/amp_4_0/platform/config/init_db.sql
===================================================================
--- /branches/amp_4_0/platform/config/init_db.sql (revision 2829)
+++ /branches/amp_4_0/platform/config/init_db.sql (working copy)
@@ -406,6 +406,7 @@
id serial PRIMARY KEY,
name varchar(64) NOT NULL,
device_ip varchar(64) DEFAULT NULL,
+ device_type varchar(64) DEFAULT NULL,
from_time varchar(64) NOT NULL,
to_time varchar(64) DEFAULT NULL,
timeout integer DEFAULT 0,
\ No newline at end of file
Index: /branches/amp_4_0/src/webui/webui/htdocs/new/src/hive/controller/device_metrics.py
===================================================================
--- /branches/amp_4_0/src/webui/webui/htdocs/new/src/hive/controller/device_metrics.py (revision 2829)
+++ /branches/amp_4_0/src/webui/webui/htdocs/new/src/hive/controller/device_metrics.py (working copy)
@@ -25,16 +25,19 @@
def get_device_metrics(request):
- """ Fetch the device metrics data """
+ """Fetch the device metrics data"""
try:
req_body = json.loads(request.body)
agent_host = req_body.get("agent_host", None)
+ device_type = req_body.get("device_type", "vapv") # <-- NEW (default to an)
interval = req_body.get("interval", "1m")
time_from = req_body.get("from", None)
time_to = req_body.get("to", None)
metric_name = req_body.get("metric_name", None)
- json_response = fetch_device_metrics(agent_host, interval, metric_name, time_from, time_to)
+ json_response = fetch_device_metrics(
+ agent_host, device_type, interval, metric_name, time_from, time_to
+ )
return JsonResponse(json_response)
\ No newline at end of file
Index: /branches/amp_4_0/src/webui/webui/htdocs/new/src/hive/db/device_metric_queries.py
===================================================================
--- /branches/amp_4_0/src/webui/webui/htdocs/new/src/hive/db/device_metric_queries.py (revision 2829)
+++ /branches/amp_4_0/src/webui/webui/htdocs/new/src/hive/db/device_metric_queries.py (working copy)
@@ -5,8 +5,28 @@
class DeviceMetrics:
- @staticmethod
- def get_device_stats(time_from, time_to):
+ def __init__(self, device_type):
+ # Normalize and map device_type to the corresponding table
+ device_type = (device_type or "an").lower()
+ table_map = {
+ "apv": "an_device_metrics",
+ "vapv": "an_device_metrics",
+ "ag": "ag_device_metrics",
+ "vxag": "ag_device_metrics",
+ "asf": "asf_device_metrics",
+ "vasf": "asf_device_metrics"
+ }
+ storage_map = {
+ "apv": "an_device_storage",
+ "vapv": "an_device_storage",
+ "asf": "asf_device_storage",
+ "vasf": "asf_device_storage"
+ }
+ self.metrics_table = table_map.get(device_type, "an_device_metrics")
+ self.storage_table = storage_map.get(device_type, None) # shared storage table
+ self.has_memory_metrics = self.metrics_table != "ag_device_metrics"
+
+ def get_device_stats(self, time_from, time_to):
"""
Fetch latest CPU, MEM, NET_MEM, Connections per agent_host
"""
@@ -20,7 +40,7 @@
COALESCE((last(connections, time)), 0) AS connections,
COALESCE(last(total_in, time), 0) AS received,
COALESCE(last(total_out, time), 0) AS sent
- FROM an_device_metrics
+ FROM {self.metrics_table}
WHERE time >= {time_from}
AND time <= {time_to}
GROUP BY agent_host;
@@ -39,8 +59,7 @@
return response
- @staticmethod
- def get_throughput_data(interval, time_from, time_to):
+ def get_throughput_data(self, interval, time_from, time_to):
"""
Fetch throughput (received/sent in bps) per agent_host over time buckets
"""
@@ -52,7 +71,7 @@
agent_host,
first(total_in, time)::double precision AS total_in,
first(total_out, time)::double precision AS total_out
- FROM an_device_metrics
+ FROM {self.metrics_table}
WHERE time >= {time_from}
AND time <= {time_to}
GROUP BY ts, agent_host
@@ -87,8 +106,7 @@
return response
- @staticmethod
- def get_cpu_usage_metrics(agent_host, interval, time_from, time_to):
+ def get_cpu_usage_metrics(self, agent_host, interval, time_from, time_to):
"""
CPU mean over time buckets per agent_host
"""
@@ -98,7 +116,7 @@
time_bucket_gapfill('{interval}', time, {time_from}, {time_to}) AS ts,
agent_host,
COALESCE(AVG(cpu_usage)::bigint, 0) AS cpu
- FROM an_device_metrics
+ FROM {self.metrics_table}
WHERE time >= {time_from}
AND time <= {time_to}
AND agent_host = '{agent_host}'
@@ -109,14 +127,13 @@
response = DBClient.execute_query(req)
field_casts = {
- "cpu_usage": int
+ "cpu": int
}
response["data"] = cast_fields(response["data"], field_casts)
return response
- @staticmethod
- def get_mem_usage_metrics(agent_host, interval, time_from, time_to):
+ def get_mem_usage_metrics(self, agent_host, interval, time_from, time_to):
"""
Memory metrics over time buckets per agent_host
"""
@@ -127,7 +144,7 @@
agent_host,
COALESCE(AVG(mem_usage)::bigint, 0) AS memory_usage,
COALESCE(AVG(net_mem_usage)::bigint, 0) AS network_mem_usage
- FROM an_device_metrics
+ FROM {self.metrics_table}
WHERE time >= {time_from}
AND time <= {time_to}
AND agent_host = '{agent_host}'
@@ -145,18 +162,19 @@
return response
- @staticmethod
- def get_disk_usage_metrics(agent_host, interval, time_from, time_to):
+ def get_disk_usage_metrics(self, agent_host, interval, time_from, time_to):
"""
Disk usage percentage over time buckets per agent_host
"""
+ if not self.storage_table:
+ return {"data": []}
query = f"""
SELECT
time_bucket_gapfill('{interval}', time, {time_from}, {time_to}) AS ts,
agent_host,
COALESCE((AVG(used) * 100.0) / NULLIF(AVG(size), 0), 0) AS disk_usage
- FROM an_device_storage
+ FROM {self.storage_table}
WHERE time >= {time_from}
AND time <= {time_to}
AND agent_host = %s
@@ -178,8 +196,7 @@
return response
- @staticmethod
- def get_network_throughput(agent_host, interval, time_from, time_to):
+ def get_network_throughput(self, agent_host, interval, time_from, time_to):
"""
Network throughput (bits/sec) over time buckets per agent_host
"""
@@ -208,7 +225,7 @@
agent_host,
first(total_out, time) AS total_out,
first(total_in, time) AS total_in
- FROM an_device_metrics
+ FROM {self.metrics_table}
WHERE time >= {time_from}
AND time <= {time_to}
AND agent_host = '{agent_host}'
@@ -227,8 +244,7 @@
return response
- @staticmethod
- def get_ssl_connections(agent_host, interval, time_from, time_to):
+ def get_ssl_connections(self, agent_host, interval, time_from, time_to):
"""
SSL connections (sum of total_openssl_conns) over time buckets per agent_host
"""
@@ -238,7 +254,7 @@
time_bucket_gapfill('{interval}', time, {time_from}, {time_to}) AS ts,
agent_host,
COALESCE(SUM(total_openssl_conns), 0) AS ssl_connection
- FROM an_device_metrics
+ FROM {self.metrics_table}
WHERE time >= {time_from}
AND time <= {time_to}
AND agent_host = '{agent_host}'
@@ -255,8 +271,7 @@
return response
- @staticmethod
- def get_connections(agent_host, interval, time_from, time_to):
+ def get_connections(self, agent_host, interval, time_from, time_to):
"""
Average active connections over time buckets per agent_host
"""
@@ -266,7 +281,7 @@
time_bucket_gapfill('{interval}', time, {time_from}, {time_to}) AS ts,
agent_host,
COALESCE(AVG(connections), 0) AS connection
- FROM an_device_metrics
+ FROM {self.metrics_table}
WHERE time >= {time_from}
AND time <= {time_to}
AND agent_host = '{agent_host}'
@@ -283,8 +298,7 @@
return response
- @staticmethod
- def get_requests(agent_host, interval, time_from, time_to):
+ def get_requests(self, agent_host, interval, time_from, time_to):
"""
Average active requests over time buckets per agent_host
"""
@@ -294,7 +308,7 @@
time_bucket_gapfill('{interval}', time, {time_from}, {time_to}) AS ts,
agent_host,
COALESCE(AVG(requests), 0) AS requests
- FROM an_device_metrics
+ FROM {self.metrics_table}
WHERE time >= {time_from}
AND time <= {time_to}
AND agent_host = '{agent_host}'
@@ -339,4 +353,183 @@
}
response["data"] = cast_fields(response["data"], field_casts)
- return response
\ No newline at end of file
+ return response
+
+ @staticmethod
+ def get_active_sessions(agent_host, interval, time_from, time_to):
+ """
+ Returns total active sessions over time buckets for AG devices.
+ """
+
+ query = f"""
+ SELECT
+ time_bucket_gapfill('{interval}', time, {time_from}, {time_to}) AS ts,
+ agent_host,
+ COALESCE(SUM(active_sessions), 0) AS session
+ FROM ag_virtual_site_stats
+ WHERE
+ time >= {time_from}
+ AND time <= {time_to}
+ AND agent_host = '{agent_host}'
+ GROUP BY ts, agent_host
+ ORDER BY ts ASC;
+ """
+
+ req = {"query": query}
+ response = DBClient.execute_query(req)
+
+ field_casts = {
+ "session": float
+ }
+ response["data"] = cast_fields(response["data"], field_casts)
+
+ return response
+
+ def get_device_summary_data(self, agent_host, time_from, time_to):
+ """
+ Returns aggregated device summary stats over the full time range.
+ Includes CPU, Memory, Net Memory, Connections, Throughput and Disk Usage.
+ """
+
+ storage_cte = ""
+ storage_join = ""
+ disk_select = "0 AS avg_disk_usage"
+
+ if self.storage_table:
+ storage_cte = f"""
+ WITH storage_avg AS (
+ SELECT
+ agent_host,
+ (AVG(used) * 100.0) / NULLIF(AVG(size), 0) AS avg_disk_usage
+ FROM {self.storage_table}
+ WHERE agent_host = '{agent_host}'
+ AND time BETWEEN {time_from} AND {time_to}
+ GROUP BY agent_host
+ )
+ """
+ storage_join = "LEFT JOIN storage_avg s ON m.agent_host = s.agent_host"
+ disk_select = "COALESCE(MAX(s.avg_disk_usage), 0) AS avg_disk_usage"
+
+ mem_select = (
+ "COALESCE(AVG(m.mem_usage), 0) AS avg_mem,"
+ if self.has_memory_metrics
+ else "0 AS avg_mem,"
+ )
+
+ query = f"""
+ {storage_cte}
+ SELECT
+ m.agent_host,
+ COALESCE(AVG(m.cpu_usage), 0) AS avg_cpu,
+ {mem_select}
+ COALESCE(AVG(m.net_mem_usage), 0) AS avg_net_mem,
+ COALESCE(AVG(m.connections), 0) AS avg_connections,
+ COALESCE(AVG(m.requests), 0) AS avg_requests,
+ COALESCE(ROUND(AVG(m.total_in * 8), 2), 0) AS avg_in_bps,
+ COALESCE(ROUND(AVG(m.total_out * 8), 2), 0) AS avg_out_bps,
+ {disk_select}
+ FROM {self.metrics_table} m
+ {storage_join}
+ WHERE m.agent_host = '{agent_host}'
+ AND m.time BETWEEN {time_from} AND {time_to}
+ GROUP BY m.agent_host;
+ """
+
+ req = {"query": query}
+ response = DBClient.execute_query(req)
+
+ response["data"] = cast_fields(
+ response["data"],
+ {
+ "avg_cpu": float,
+ "avg_mem": float,
+ "avg_net_mem": float,
+ "avg_connections": float,
+ "avg_requests": float,
+ "avg_in_bps": float,
+ "avg_out_bps": float,
+ "avg_disk_usage": float,
+ },
+ )
+ return response
+
+ def get_device_historical_data(self, agent_host, interval, time_from, time_to):
+ """
+ Historical metrics with per-bucket disk usage (safe).
+ """
+
+ disk_cte = ""
+ disk_join = ""
+ disk_select = "0 AS avg_disk_usage"
+
+ if self.storage_table:
+ disk_cte = f"""
+ , storage AS (
+ SELECT
+ time_bucket_gapfill('{interval}', time, {time_from}, {time_to}) AS ts,
+ agent_host,
+ (AVG(used) * 100.0) / NULLIF(AVG(size), 0) AS disk_usage
+ FROM {self.storage_table}
+ WHERE agent_host = '{agent_host}'
+ AND time BETWEEN {time_from} AND {time_to}
+ GROUP BY ts, agent_host
+ )
+ """
+ disk_join = """
+ LEFT JOIN storage s
+ ON m.ts = s.ts
+ AND m.agent_host = s.agent_host
+ """
+ disk_select = "COALESCE(s.disk_usage, 0) AS avg_disk_usage"
+
+ query = f"""
+ WITH metrics AS (
+ SELECT
+ time_bucket_gapfill('{interval}', time, {time_from}, {time_to}) AS ts,
+ agent_host,
+ AVG(cpu_usage) AS avg_cpu,
+ AVG(mem_usage) AS avg_mem,
+ AVG(net_mem_usage) AS avg_net_mem,
+ AVG(connections) AS avg_connections,
+ AVG(requests) AS avg_requests,
+ AVG(total_in * 8) AS avg_in_bps,
+ AVG(total_out * 8) AS avg_out_bps
+ FROM {self.metrics_table}
+ WHERE agent_host = '{agent_host}'
+ AND time BETWEEN {time_from} AND {time_to}
+ GROUP BY ts, agent_host
+ )
+ {disk_cte}
+ SELECT
+ m.ts,
+ m.agent_host,
+ COALESCE(m.avg_cpu, 0) AS avg_cpu,
+ COALESCE(m.avg_mem, 0) AS avg_mem,
+ COALESCE(m.avg_net_mem, 0) AS avg_net_mem,
+ COALESCE(m.avg_connections, 0) AS avg_connections,
+ COALESCE(m.avg_requests, 0) AS avg_requests,
+ COALESCE(m.avg_in_bps, 0) AS avg_in_bps,
+ COALESCE(m.avg_out_bps, 0) AS avg_out_bps,
+ {disk_select}
+ FROM metrics m
+ {disk_join}
+ ORDER BY m.ts ASC;
+ """
+
+ req = {"query": query}
+ response = DBClient.execute_query(req)
+
+ response["data"] = cast_fields(
+ response["data"],
+ {
+ "avg_cpu": float,
+ "avg_mem": float,
+ "avg_net_mem": float,
+ "avg_connections": float,
+ "avg_requests": float,
+ "avg_in_bps": float,
+ "avg_out_bps": float,
+ "avg_disk_usage": float,
+ },
+ )
+ return response
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 2829)
+++ /branches/amp_4_0/src/webui/webui/htdocs/new/src/hive/db/slb_stats_queries.py (working copy)
@@ -686,3 +686,114 @@
}
response["data"] = cast_fields(response["data"], field_casts)
return response
+
+ @staticmethod
+ def get_real_service_summary_data(agent_host, real_server_id, time_from, time_to):
+ """
+ Returns SLB Real Service summary stats aggregated over the full time range
+ for the given agent_host and real_server_id.
+ """
+ query = f"""
+ SELECT
+ agent_host,
+ "real_server_id" AS rs_name,
+ addr,
+ port,
+ protocol,
+
+ -- Average metrics
+ COALESCE(CAST(AVG(rs_conn_cnt) AS bigint), 0) AS avg_conn_cnt,
+ COALESCE(CAST(AVG(rs_conn_per_sec) AS bigint), 0) AS avg_conn_per_sec,
+ COALESCE(ROUND(CAST(AVG(rs_in_byte_per_sec * 8) AS numeric), 2), 0) AS avg_in_byte_per_sec,
+ COALESCE(ROUND(CAST(AVG(rs_out_byte_per_sec * 8) AS numeric), 2), 0) AS avg_out_byte_per_sec,
+ COALESCE(AVG(rs_cnt_of_req), 0) AS avg_outstanding_req,
+
+ -- Average hits
+ COALESCE(
+ ROUND(
+ CAST(
+ (
+ MAX(rs_total_hits) - MIN(rs_total_hits)
+ ) / EXTRACT(EPOCH FROM (MAX(time) - MIN(time)))
+ AS numeric), 2), 0
+ ) AS avg_hits
+
+ FROM apv_real_stats
+ WHERE
+ agent_host = '{agent_host}'
+ AND "real_server_id" = '{real_server_id}'
+ AND time >= {time_from}
+ AND time <= {time_to}
+ GROUP BY
+ agent_host, "real_server_id", addr, port, protocol
+ ORDER BY "real_server_id";
+ """
+
+ 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_outstanding_req": int,
+ "avg_hits": float
+ }
+ response["data"] = cast_fields(response["data"], field_casts)
+ return response
+
+ @staticmethod
+ def get_real_service_historical_data(agent_host, real_server_id, interval, time_from, time_to):
+ """
+ Returns historical Real Service stats aggregated over time buckets.
+ Includes:
+ - Throughput (in/out)
+ - Connection count and connections/sec
+ - Total hits (delta)
+ """
+
+ query = f"""
+ SELECT
+ time_bucket_gapfill('{interval}', time, {time_from}, {time_to}) AS ts,
+ agent_host,
+ "real_server_id" AS rs_name,
+
+ -- Bandwidth (Bytes/sec)
+ COALESCE(AVG(rs_in_byte_per_sec), 0) AS avg_in_byte_per_sec,
+ COALESCE(AVG(rs_out_byte_per_sec), 0) AS avg_out_byte_per_sec,
+
+ -- Connections
+ COALESCE(AVG(rs_conn_cnt), 0) AS avg_conn_cnt,
+ COALESCE(AVG(rs_conn_per_sec), 0) AS avg_conn_per_sec,
+
+ -- Requests
+ COALESCE(AVG(rs_cnt_of_req), 0) AS outstanding_req,
+
+ -- Total Hits (delta)
+ COALESCE(MAX(rs_total_hits) - MIN(rs_total_hits), 0) AS hit_diff
+
+ FROM apv_real_stats
+ WHERE agent_host ~ %s
+ AND real_server_id ~ %s
+ AND time >= {time_from}
+ AND time <= {time_to}
+ GROUP BY ts, agent_host, real_server_id
+ ORDER BY ts ASC;
+ """
+
+ params = [agent_host, real_server_id]
+ req = {"query": query, "params": params}
+ response = DBClient.execute_query(req)
+
+ field_casts = {
+ "avg_in_byte_per_sec": float,
+ "avg_out_byte_per_sec": float,
+ "avg_conn_cnt": int,
+ "avg_conn_per_sec": float,
+ "outstanding_req": int,
+ "hit_diff": int
+ }
+
+ response["data"] = cast_fields(response["data"], field_casts)
+ 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 2829)
+++ /branches/amp_4_0/src/webui/webui/htdocs/new/src/hive/report/generate_pdf_report.py (working copy)
@@ -38,16 +38,28 @@
def __init__(self):
pass
- def generate_pdf_report(self, filename, category, data_dict, data_summary_dict, start_time, end_time):
+ def generate_pdf_report(self, filename, category, data_dict, data_summary_dict, start_time, end_time,
+ device_name=None, device_type=None):
"""
Generate a PDF report for LLB, SLB, or any other category dynamically.
"""
try:
os.makedirs(REPORT_FILE_PATH, exist_ok=True)
- pdf = SimpleDocTemplate(REPORT_FILE_PATH + filename, pagesize=letter)
+ pdf = SimpleDocTemplate(
+ REPORT_FILE_PATH + filename,
+ pagesize=letter,
+ leftMargin=50,
+ rightMargin=50
+ )
+
elements = []
styles = getSampleStyleSheet()
- styles.add(ParagraphStyle(name="AMPReportHeading3", parent=styles["Heading3"], leftPadding=0))
+ styles.add(ParagraphStyle(name="AMPReportHeading3", parent=styles["Heading3"], leftPadding=0, alignment=0))
+ styles.add(ParagraphStyle(name="CenteredTitle", parent=styles["Title"], alignment=1))
+ # For all other text blocks:
+ styles.add(ParagraphStyle('LeftText', parent=styles["Normal"], alignment=0))
+ styles.add(ParagraphStyle('Heading3Left', parent=styles["Heading3"], alignment=0))
+ styles.add(ParagraphStyle('Heading4Left', parent=styles["Heading4"], alignment=0))
# Header
im = Image(LOGO_PATH, 2 * inch, 0.8 * inch)
\ No newline at end of file
@@ -59,32 +71,48 @@
category_name = "SLB Virtual Service"
elif "rs" in category:
category_name = "SLB Real Service"
+ elif "device_status" in category:
+ category_name = "Device Status"
else:
category_name = str(category).upper()
title = f"{category_name} Report"
- elements.append(Paragraph(f"{title}", styles["Title"]))
+ elements.append(Paragraph(f"{title}", styles["CenteredTitle"]))
elements += [Spacer(1, 20)]
- elements.append(Paragraph(f"Statistics From : {start_time}", styles["Heading4"]))
- elements.append(Paragraph(f"Statistics To : {end_time}", styles["Heading4"]))
+ if device_name is not None:
+ elements.append(Paragraph(f"Device Name : {device_name}", styles["Heading4Left"]))
+ if device_type is not None:
+ elements.append(Paragraph(f"Device Type : {device_type}", styles["Heading4Left"]))
+ elements.append(Paragraph(f"Statistics From : {start_time}", styles["Heading4Left"]))
+ elements.append(Paragraph(f"Statistics To : {end_time}", styles["Heading4Left"]))
elements.append(Spacer(1, 10))
# --- 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)
+ summary_headers, summary_fields = self.get_summary_headers_and_fields(category, device_type)
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]
+ row_values = [summary_data.get(field, entity_name if field == "entity_name" else 0)
+ for field in summary_fields]
table = self.get_table_data(summary_headers, [row_values])
elements += [Spacer(1, 15), table, Spacer(1, 25)]
# --- Detailed Section ---
if data_dict:
elements.append(Paragraph("Detailed Report:", styles["AMPReportHeading3"]))
- section_config = self.get_detailed_sections(category)
+ section_config = self.get_detailed_sections(category, device_type)
for entity_name, metrics in data_dict.items():
- elements.append(Paragraph(f"Virtual Service Name: {str(entity_name)}", styles["Heading3"]))
+ # Title
+ if "vs" in category:
+ label = "Virtual Service Name"
+ elif "rs" in category:
+ label = f"Real Service Name"
+ elif "device_status" in category:
+ label = f"Device"
+ else:
+ label = str(entity_name)
+ elements.append(Paragraph(f"{label}: {entity_name}", styles["Heading3Left"]))
elements.append(Spacer(1, 15))
# Render each subsection (e.g., throughput, usage, hits)
\ No newline at end of file
@@ -94,7 +122,7 @@
fields = section["fields"]
if title == 'Hits Distribution':
- elements.append(Paragraph("Hits Distribution", styles["Heading4"]))
+ elements.append(Paragraph("Hits Distribution", styles["Heading4Left"]))
elements.append(Spacer(1, 10))
# Prepare data as [(hit_type, total), ...]
\ No newline at end of file
@@ -108,7 +136,7 @@
table = self.get_table_data(["Hit Type", "Number"], table_data)
elements += [table, Spacer(1, 25)]
else:
- elements.append(Paragraph(title, styles["Heading4"]))
+ elements.append(Paragraph(title, styles["Heading4Left"]))
elements.append(Spacer(1, 10))
# Clean time format
\ No newline at end of file
@@ -128,11 +156,33 @@
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)
+ styles = getSampleStyleSheet()
+ # Wrap headers & data so text can break into multiple lines
+ wrapped_headers = [
+ Paragraph(f"{h}", styles["Normal"]) for h in headers
+ ]
+
+ wrapped_data = []
+ for row in data:
+ wrapped_data.append([
+ Paragraph(str(cell), styles["Normal"]) for cell in row
+ ])
+
+ table_data = [wrapped_headers] + wrapped_data
+
+ # Dynamic column width (page-safe)
+ col_width = 540 / len(headers)
+ col_widths = [col_width] * len(headers)
+
+ table = Table(
+ table_data,
+ colWidths=col_widths,
+ repeatRows=1, # Header repeats on new page
+ splitByRow=True # Allows clean page breaks
+ )
+
+ data_len = len(data)
for each in range(data_len):
if each == 0:
bg_color = colors.lightgrey
\ No newline at end of file
@@ -143,23 +193,45 @@
('FONT', (0, 0), (-1, -1), 'Helvetica'), ]))
return table
- def get_summary_headers_and_fields(self, category):
+ def get_summary_headers_and_fields(self, category, device_type=None):
"""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"]
+ ["entity_name", "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",
+ ["entity_name", "avg_conn_cnt", "avg_conn_per_sec", "avg_in_byte_per_sec", "avg_out_byte_per_sec",
"avg_hits_per_sec"]
)
+ elif "rs" in category.lower():
+ return (
+ ["Real Service", "Conn Count", "Conn/sec", "Inbound (bps)", "Outbound (bps)", "Requests", "Hits"],
+ ["entity_name", "avg_conn_cnt", "avg_conn_per_sec", "avg_in_byte_per_sec", "avg_out_byte_per_sec",
+ "avg_outstanding_req", "avg_hits_per_sec"]
+ )
+ elif "device_status" in category.lower():
+ if device_type in ['vAPV', 'APV', 'vASF', 'ASF']:
+ return (
+ ["CPU Usage (%)", "System Memory Usage (%)", "Network Memory Usage", "Disk Usage (%)",
+ "Inbound (bps)", "Outbound (bps)", "Connections", "Requests"],
+ ["avg_cpu", "avg_mem", "net_mem_usage", "avg_disk_usage", "avg_in_bps", "avg_out_bps",
+ "avg_connections", "avg_requests"]
+ )
+ else:
+ return (
+ ["CPU Usage (%)", "Network Memory Usage (%)", "Disk Usage (%)", "Inbound (bps)", "Outbound (bps)",
+ "Connections Number", "Requests Number"],
+ ["avg_cpu", "net_mem_usage", "avg_disk_usage", "avg_in_bps", "avg_out_bps",
+ "avg_connections", "avg_requests"]
+ )
else:
return ["Entity", "Metric1", "Metric2"], ["metric1", "metric2"] # placeholder for future types
- def get_detailed_sections(self, category):
+ def get_detailed_sections(self, category, device_type=None):
"""Return detailed table configuration per category."""
if "llb" in category.lower():
return [
\ No newline at end of file
@@ -174,9 +246,47 @@
{"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": "Hits Distribution", "headers": ["Hit Type", "Number"], "fields": []},
{"title": "Open Connections", "headers": ["Time", "Connection"], "fields": ["avg_conn_cnt"]},
{"title": "Connections Per Second", "headers": ["Time", "Connection"], "fields": ["avg_conn_per_sec"]},
]
+ elif "rs" 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": "Outstanding Requests", "headers": ["Time", "Request"], "fields": ["outstanding_req"]},
+ {"title": "Requests Number", "headers": ["Time", "Hits"], "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"]},
+ ]
+ elif "device_status" in category.lower():
+ if device_type in ['vAPV', 'APV', 'vASF', 'ASF']:
+ return [
+ {"title": "CPU Usage (%)", "headers": ["Time", "CPU"],
+ "fields": ["avg_cpu"]},
+ {"title": "Memory Usage (%)", "headers": ["Time", "System Memory", "Network Memory"],
+ "fields": ["avg_mem", "avg_net_mem"]},
+ {"title": "Disk Usage", "headers": ["Time", "Disk"], "fields": ["avg_disk_usage"]},
+ {"title": "Network Throughput (bps)", "headers": ["Time", "sent", "received"],
+ "fields": ["avg_out_bps", "avg_in_bps"]},
+ {"title": "Connections Number", "headers": ["Time", "Connection"],
+ "fields": ["avg_connections"]},
+ {"title": "Requests Number", "headers": ["Time", "Request"],
+ "fields": ["avg_requests"]},
+ ]
+ else:
+ return [
+ {"title": "CPU Usage (%)", "headers": ["Time", "CPU"],
+ "fields": ["avg_cpu"]},
+ {"title": "Memory Usage (%)", "headers": ["Time", "Network Memory"],
+ "fields": ["avg_net_mem"]},
+ {"title": "Disk Usage", "headers": ["Time", "Disk"], "fields": ["avg_disk_usage"]},
+ {"title": "Network Throughput (bps)", "headers": ["Time", "sent", "received"],
+ "fields": ["avg_out_bps", "avg_in_bps"]},
+ {"title": "Connections Number", "headers": ["Time", "Connection"],
+ "fields": ["avg_connections"]},
+ {"title": "Requests Number", "headers": ["Time", "Request"],
+ "fields": ["avg_requests"]},
+ ]
else:
- return []
+ return []
\ No newline at end of file
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 2829)
+++ /branches/amp_4_0/src/webui/webui/htdocs/new/src/hive/report/generate_report.py (working copy)
@@ -4,7 +4,8 @@
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
+ get_virtual_service_detailed_data, get_virtual_service_summary_data, get_real_service_summary_data, \
+ get_real_service_detailed_data, get_device_detailed_data, get_device_summary_data
from cm.lib.libbasic_operation import oper_log
from hive.custom_exceptions import generic_exception as ge
from hive.report.report_queries import ReportDB
\ No newline at end of file
@@ -30,6 +31,8 @@
return download_report(request.GET.get('filename'))
elif path == 'log':
return get_all_report_log(request)
+ elif report_id:
+ return get_report(report_id)
else:
return get_all_reports(request)
\ No newline at end of file
@@ -45,6 +48,21 @@
return JsonResponse({"error": f"Unexpected error: {str(e)}"}, status=500)
+def get_report(report_id):
+ """
+ Handle GET request to fetch report data for report_id.
+ """
+ if not report_id:
+ return JsonResponse({"error": "Missing report_id"}, status=400)
+ try:
+ report_details = ReportDB.get_report_details(report_id)
+
+ return JsonResponse({"report data": report_details}, status=200, safe=False)
+ except Exception as e:
+ oper_log("error", "system", f"Fetch of Report data failed for report_id {report_id}: {str(e)}")
+ return JsonResponse({"error": f"FFetch of Report data failed for report id: {report_id}"}, status=500)
+
+
def get_all_reports(request):
"""
Handle GET request to fetch all reports.
\ No newline at end of file
@@ -58,7 +76,7 @@
return JsonResponse({"reports": reports}, status=200, safe=False)
except Exception as e:
oper_log("error", "system", f"Unexpected error in get_all_reports: {str(e)}")
- return JsonResponse({"error": f"Unexpected error: {str(e)}"}, status=500)
+ return JsonResponse({"error": f"Fetch of all the report data failed"}, status=500)
def get_all_report_log(request):
\ No newline at end of file
@@ -74,7 +92,7 @@
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)
+ return JsonResponse({"error": f"Fetching the report logs failed"}, status=500)
def save_report(request):
\ No newline at end of file
@@ -96,6 +114,7 @@
data.get("from_time"),
data.get("to_time"),
data.get("device_ip"),
+ data.get("device_type", None),
data.get("send_to"),
)
\ No newline at end of file
@@ -125,6 +144,7 @@
data.get("subject_type"),
data.get("subject_name"),
data.get("device_ip"),
+ data.get("device_type", None),
data.get("from_time"),
data.get("to_time"),
data.get("send_to"),
\ No newline at end of file
@@ -216,9 +236,10 @@
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")
+ sub_type = report.get("subject_type")
time_interval = get_dynamic_interval(from_time, to_time)
- if report.get("subject_type") == "service_status":
+ if sub_type == "service_status":
sub_name = report.get("subject_name", "")
if "LLB" in sub_name:
report_name = generate_llb_report(report, from_time, to_time, time_interval)
\ No newline at end of file
@@ -226,29 +247,40 @@
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)
+ elif "SLB_rs" in sub_name:
+ agent_host = report.get("device_ip", "")
+ rs_name = sub_name.split("(")[0].strip()
+ report_name = generate_slb_rs_report(agent_host, rs_name, from_time, to_time, time_interval)
- 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)
+ elif sub_type == "device_status":
+ agent_host = report.get("device_ip", "")
+ device_name = report["subject_name"]
+ dev_type = report["device_type"]
+ report_name = generate_device_status_report(agent_host, device_name, dev_type, from_time, to_time,
+ time_interval)
else:
return JsonResponse({"error": f"Unsupported report type: {report.get('subject_type')}"}, status=400)
+ 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)
+
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)
\ No newline at end of file
@@ -289,3 +321,56 @@
report_name, "SLB_vs", data_dict, data_summary_dict, display_start_time_str, display_end_time_str
)
return report_name
+
+
+def generate_slb_rs_report(agent_host, rs_name, from_time, to_time, time_interval):
+ data_dict = get_real_service_detailed_data(agent_host, rs_name, from_time, to_time, time_interval)
+ data_summary_dict = get_real_service_summary_data(agent_host, rs_name, from_time, to_time)
+
+ (
+ 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"SLB_RS_Statistics_Report_from_{filename_start_time_str}_to_{filename_end_time_str}.pdf"
+ report_generator = Report()
+ report_generator.generate_pdf_report(
+ report_name, "SLB_rs", data_dict, data_summary_dict, display_start_time_str, display_end_time_str
+ )
+ return report_name
+
+
+def generate_device_status_report(agent_host, device_name, device_type, from_time, to_time, time_interval):
+ data_dict = get_device_detailed_data(agent_host, device_type, from_time, to_time, time_interval)
+ data_summary_dict = get_device_summary_data(agent_host, device_type, from_time, to_time)
+
+ (
+ 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"Device_Status_Report_{agent_host}_from_{filename_start_time_str}_to_{filename_end_time_str}.pdf"
+ )
+
+ report_generator = Report()
+ report_generator.generate_pdf_report(
+ report_name,
+ "device_status",
+ data_dict,
+ data_summary_dict,
+ display_start_time_str,
+ display_end_time_str,
+ device_name,
+ device_type
+ )
+
+ return report_name
\ No newline at end of file
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 (revision 2829)
+++ /branches/amp_4_0/src/webui/webui/htdocs/new/src/hive/report/report_data_service.py (working copy)
@@ -1,6 +1,7 @@
from hive.services.utils import convert_time
from hive.db.llb_stats_queries import LLBStatsDB
from hive.db.slb_stats_queries import SLBStats
+from hive.db.device_metric_queries import DeviceMetrics
from django.http import JsonResponse
from hive.utils import andebug
\ No newline at end of file
@@ -81,7 +82,7 @@
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)
+ 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 {}
\ No newline at end of file
@@ -150,4 +151,164 @@
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
+ return JsonResponse({"error": f"Error while fetching SLB Virtual Service data: {str(e)}"}, status=500)
+
+
+def get_real_service_summary_data(agent_host, rs_name, time_from, time_to):
+ """ Returns data for Real Service Summary Report """
+ try:
+ from_time = convert_time(time_from, "now() - interval '15 minutes'")
+ to_time = convert_time(time_to, "now()")
+ response = SLBStats.get_real_service_summary_data(agent_host, rs_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"]:
+ rs_name = row.get("rs_name")
+ summary_dict[rs_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_outstanding_req": row.get("avg_outstanding_req", 0),
+ "avg_hits": row.get("avg_hits", 0),
+ }
+
+ return summary_dict
+ except Exception as e:
+ return JsonResponse({"error": f"Error while fetching Real Service Summary data: {str(e)}"}, status=500)
+
+
+def get_real_service_detailed_data(agent_host, rs_name, time_from, time_to, interval="20s"):
+ """Returns detailed SLB Real 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_real_service_historical_data(agent_host, rs_name, interval, from_time, to_time)
+
+ # Defensive check
+ if not response or "data" not in response or not isinstance(response["data"], list):
+ return {}
+
+ slb_rs_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", "outstanding_req",
+ "hit_diff"
+ ]
+
+ for row in response["data"]:
+ real_service = row.get("rs_name", "unknown")
+ ts = row.get("ts")
+ if not ts:
+ continue
+
+ if real_service not in slb_rs_dict:
+ # Initialize lists for all fields
+ slb_rs_dict[real_service] = {"time": []}
+ for field in metric_fields:
+ slb_rs_dict[real_service][field] = []
+
+ rs_data = slb_rs_dict[real_service]
+
+ # Append timestamp
+ rs_data["time"].append(ts)
+
+ # Append all metric fields dynamically
+ for field in metric_fields:
+ rs_data[field].append(row.get(field, 0))
+
+ return slb_rs_dict
+
+ except Exception as e:
+ return JsonResponse({"error": f"Error while fetching SLB Real Service data: {str(e)}"}, status=500)
+
+
+def get_device_summary_data(agent_host, device_type, time_from, time_to):
+ """ Returns summary statistics for Device Status Report """
+
+ try:
+ from_time = convert_time(time_from, "now() - interval '15 minutes'")
+ to_time = convert_time(time_to, "now()")
+
+ metrics = DeviceMetrics(device_type)
+ response = metrics.get_device_summary_data(agent_host, 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"]:
+ agent = row.get("agent_host")
+
+ summary_dict[agent] = {
+ "avg_cpu": row.get("avg_cpu", 0),
+ "avg_mem": row.get("avg_mem", 0),
+ "avg_net_mem": row.get("avg_net_mem", 0),
+ "avg_connections": row.get("avg_connections", 0),
+ "avg_in_bps": row.get("avg_in_bps", 0),
+ "avg_out_bps": row.get("avg_out_bps", 0),
+ "avg_disk_usage": row.get("avg_disk_usage", 0),
+ "avg_requests": row.get("avg_requests", 0)
+ }
+
+ return summary_dict
+
+ except Exception as e:
+ return JsonResponse({"error": f"Error while fetching Device Summary data: {str(e)}"}, status=500)
+
+
+def get_device_detailed_data(agent_host, device_type, time_from, time_to, interval="20s"):
+ """Returns detailed device metrics for report generation."""
+
+ try:
+ from_time = convert_time(time_from, "now() - interval '15 minutes'")
+ to_time = convert_time(time_to, "now()")
+
+ metrics = DeviceMetrics(device_type)
+ response = metrics.get_device_historical_data(agent_host, interval, from_time, to_time)
+
+ if not response or "data" not in response or not isinstance(response["data"], list):
+ return {}
+
+ device_dict = {}
+
+ metric_fields = [
+ "avg_cpu",
+ "avg_mem",
+ "avg_net_mem",
+ "avg_connections",
+ "avg_in_bps",
+ "avg_out_bps",
+ "avg_disk_usage",
+ "avg_requests"
+ ]
+
+ for row in response["data"]:
+ agent = row.get("agent_host", "unknown")
+ ts = row.get("ts")
+
+ if not ts:
+ continue
+
+ if agent not in device_dict:
+ device_dict[agent] = {"time": []}
+ for f in metric_fields:
+ device_dict[agent][f] = []
+
+ dev_data = device_dict[agent]
+
+ dev_data["time"].append(ts)
+
+ for f in metric_fields:
+ dev_data[f].append(row.get(f, 0))
+
+ return device_dict
+
+ except Exception as e:
+ return JsonResponse({"error": f"Error while fetching Device Detailed 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 2829)
+++ /branches/amp_4_0/src/webui/webui/htdocs/new/src/hive/report/report_queries.py (working copy)
@@ -17,6 +17,7 @@
subject_type,
subject_name,
device_ip,
+ device_type,
from_time,
to_time,
send_to
@@ -43,6 +44,7 @@
subject_type,
subject_name,
device_ip,
+ device_type,
from_time,
to_time,
send_to
@@ -59,16 +61,16 @@
return []
@staticmethod
- def insert_report(name, subject_type, subject_name, from_time, to_time, device_ip=None, send_to=None):
+ def insert_report(name, subject_type, subject_name, from_time, to_time, device_ip=None, device_type=None, send_to=None):
"""
Insert a new report entry and return its id.
"""
query = """
- INSERT INTO report (name, subject_type, subject_name, device_ip, from_time, to_time, send_to)
- VALUES (%s, %s, %s, %s, %s, %s, %s)
+ INSERT INTO report (name, subject_type, subject_name, device_ip, device_type, from_time, to_time, send_to)
+ VALUES (%s, %s, %s, %s, %s, %s, %s, %s)
RETURNING id;
"""
- params = (name, subject_type, subject_name, device_ip, from_time, to_time, send_to)
+ params = (name, subject_type, subject_name, device_ip, device_type, from_time, to_time, send_to)
req = {"query": query, "params": params}
response = DBClient.execute_query(req, "postgres")
@@ -79,7 +81,7 @@
return None
@staticmethod
- def update_report(report_id, name, subject_type, subject_name, device_ip, from_time, to_time, send_to):
+ def update_report(report_id, name, subject_type, subject_name, device_ip, device_type, from_time, to_time, send_to):
"""
Update an existing report entry.
"""
@@ -90,6 +92,7 @@
subject_type = %s,
subject_name = %s,
device_ip = %s,
+ device_type = %s,
from_time = %s,
to_time = %s,
send_to = %s
Index: /branches/amp_4_0/src/webui/webui/htdocs/new/src/hive/services/device_metrics_service.py
===================================================================
--- /branches/amp_4_0/src/webui/webui/htdocs/new/src/hive/services/device_metrics_service.py (revision 2829)
+++ /branches/amp_4_0/src/webui/webui/htdocs/new/src/hive/services/device_metrics_service.py (working copy)
@@ -2,37 +2,37 @@
from hive.services.utils import construct_json_response, convert_time
-def fetch_device_metrics(agent_host, interval, metric_name, time_from, time_to):
+def fetch_device_metrics(agent_host, device_type, metric_name, interval, time_from, time_to):
time_from = convert_time(time_from, "now() - interval '15 minutes'")
time_to = convert_time(time_to, "now()")
- if metric_name and metric_name == 'cpu_usage':
- metrics = DeviceMetrics.get_cpu_usage_metrics(agent_host, interval, time_from, time_to)
- json_response = construct_json_response(metrics)
- elif metric_name and metric_name == 'memory_usage':
- metrics = DeviceMetrics.get_mem_usage_metrics(agent_host, interval, time_from, time_to)
- json_response = construct_json_response(metrics)
- elif metric_name and metric_name == 'disk_usage':
- metrics = DeviceMetrics.get_disk_usage_metrics(agent_host, interval, time_from, time_to)
- json_response = construct_json_response(metrics)
- elif metric_name and metric_name == 'network_throughput':
- metrics = DeviceMetrics.get_network_throughput(agent_host, interval, time_from, time_to)
- json_response = construct_json_response(metrics)
- elif metric_name == "ssl_connections":
- metrics = DeviceMetrics.get_ssl_connections(agent_host, interval, time_from, time_to)
- json_response = construct_json_response(metrics)
- elif metric_name == "connections":
- metrics = DeviceMetrics.get_connections(agent_host, interval, time_from, time_to)
- json_response = construct_json_response(metrics)
- elif metric_name == "requests":
- metrics = DeviceMetrics.get_requests(agent_host, interval, time_from, time_to)
- json_response = construct_json_response(metrics)
- elif metric_name == "ssl_core_utilization":
- metrics = DeviceMetrics.get_ssl_core_utilization(agent_host, interval, time_from, time_to)
- json_response = construct_json_response(metrics)
+ # Pass device_type to DB layer
+ metrics_class = DeviceMetrics(device_type)
+
+ if metric_name == 'cpu_usage':
+ metrics = metrics_class.get_cpu_usage_metrics(agent_host, interval, time_from, time_to)
+ elif metric_name == 'memory_usage':
+ metrics = metrics_class.get_mem_usage_metrics(agent_host, interval, time_from, time_to)
+ elif metric_name == 'disk_usage':
+ metrics = metrics_class.get_disk_usage_metrics(agent_host, interval, time_from, time_to)
+ elif metric_name == 'network_throughput':
+ metrics = metrics_class.get_network_throughput(agent_host, interval, time_from, time_to)
+ elif metric_name == 'ssl_connections':
+ metrics = metrics_class.get_ssl_connections(agent_host, interval, time_from, time_to)
+ elif metric_name == 'connections':
+ metrics = metrics_class.get_connections(agent_host, interval, time_from, time_to)
+ elif metric_name == 'requests':
+ metrics = metrics_class.get_requests(agent_host, interval, time_from, time_to)
+ elif metric_name == 'ssl_core_utilization':
+ metrics = metrics_class.get_ssl_core_utilization(agent_host, interval, time_from, time_to)
+ elif metric_name == 'active_sessions':
+ metrics = metrics_class.get_active_sessions(agent_host, interval, time_from, time_to)
+ elif metric_name == 'summary':
+ metrics = metrics_class.get_device_summary_data(agent_host, time_from, time_to)
+ elif metric_name == 'historical':
+ metrics = metrics_class.get_device_historical_data(agent_host, interval, time_from, time_to)
else:
- device_stats = DeviceMetrics.get_device_stats(time_from, time_to)['data']
- json_response = {
- "device_stats": device_stats
- }
- return json_response
+ metrics = metrics_class.get_device_stats(time_from, time_to)
+
+ return construct_json_response(metrics)
+