NLB-7299: Cleanedup code to remove print statements

Author: Naveen-Gopu-F5

content/nginxaas-azure/billing/usage-and-cost-estimator.md

@@ -164,7 +164,7 @@ Before using the cost analysis script:
     pip3 install azure-identity azure-mgmt-monitor
     ```
 
-4. **NGINXaaS for Azure deployment** with monitoring enabled
+4. **NGINXaaS for Azure deployment on Standard V3 Plan** with monitoring enabled
 5. **Azure AD Tenant ID** (required for authentication)
 6. **Monitoring Reader permissions** on your NGINXaaS resource
 
@@ -214,41 +214,9 @@ python3 nginxaas_cost_analysis.py \
 {{< details "View sample output" >}}
 
 ```
-🌐 Using InteractiveBrowserCredential with tenant: d106871e-7b91-4733-8423-f98586303b68
-📈 Processing 72 hours of data...
-============================================================
-📈 COST ANALYSIS SUMMARY
-============================================================
-Total Analysis Period: 72 hours
-Total Cost: $32.40
-
-🕐 HOURLY COST BREAKDOWN (First 5 hours):
-------------------------------------------------------------
-Hour 1 - 2025-11-18T00:00:00Z
-    Fixed: $0.250 | WAF: $0.000 | NCU: $0.160
-    Ports: $0.000 | Data: $0.000 | Total: $0.410
-
-Hour 2 - 2025-11-18T01:00:00Z
-    Fixed: $0.250 | WAF: $0.000 | NCU: $0.160
-    Ports: $0.000 | Data: $0.000 | Total: $0.410
-
-Hour 3 - 2025-11-18T02:00:00Z
-    Fixed: $0.250 | WAF: $0.000 | NCU: $0.160
-    Ports: $0.000 | Data: $0.000 | Total: $0.410
-
-Hour 4 - 2025-11-18T03:00:00Z
-    Fixed: $0.250 | WAF: $0.000 | NCU: $0.160
-    Ports: $0.000 | Data: $0.000 | Total: $0.410
-
-Hour 5 - 2025-11-18T04:00:00Z
-    Fixed: $0.250 | WAF: $0.000 | NCU: $0.160
-    Ports: $0.000 | Data: $0.000 | Total: $0.410
-
-... and 67 more hours
-
-✅ Cost breakdown exported to nginxaas_cost_breakdown.csv
-     📊 Summary: 72 hours, Total cost: $32.40
-✅ Cost analysis completed successfully!
+Cost breakdown exported to nginxaas_cost_breakdown.csv
+Summary: 96 hours, Total cost: $71.66
+Cost analysis completed successfully!
 ```
 
 {{< /details >}}

static/scripts/nginxaas_cost_analysis.py

@@ -69,7 +69,7 @@ def get_metrics_azure_sdk(client, resource_id, metric_name, start_time, end_time
         timespan=f"{start_time}/{end_time}",
         interval="PT1M",  # 1-minute intervals
         metricnames=metric_name,
-        aggregation="Average,Maximum,Total",
+        aggregation="Total",
     )
     return metrics_data
 
@@ -86,24 +86,17 @@ def aggregate_hourly_data(metrics_data, metric_name):
     hourly_aggregates = {}
 
     for point in data_points:
-        # SDK format - use time_stamp attribute
+        if point.total is None:
+            continue
         timestamp = point.time_stamp
         hour_key = timestamp.replace(minute=0, second=0, microsecond=0)
-        
         if hour_key not in hourly_aggregates:
             hourly_aggregates[hour_key] = {
                 'timestamp': hour_key.isoformat().replace('+00:00', 'Z'),
-                'values': [],
                 'totals': []
             }
-        
-        if metric_name == "system.interface.total_bytes":
-            total_val = point.total or 0
-            hourly_aggregates[hour_key]['totals'].append(total_val)
-        else:
-            avg_val = point.average or 0
-            max_val = point.maximum or 0
-            hourly_aggregates[hour_key]['values'].append(max_val if max_val > 0 else avg_val)
+        total_val = point.total
+        hourly_aggregates[hour_key]['totals'].append(total_val)
 
     result = []
     for hour_key in sorted(hourly_aggregates.keys()):
@@ -112,7 +105,7 @@ def aggregate_hourly_data(metrics_data, metric_name):
         if metric_name == "system.interface.total_bytes":
             final_value = sum(hour_data['totals'])
         else:
-            final_value = max(hour_data['values']) if hour_data['values'] else 0
+            final_value = max(hour_data['totals']) if hour_data['totals'] else 0
 
         result.append({
             'timestamp': hour_data['timestamp'],
@@ -141,59 +134,48 @@ def calculate_cost_breakdown(date_range, resource_id, location, credential, subs
     waf_metrics_raw = get_metrics_azure_sdk(client, resource_id, "waf.enabled", start_time, end_time)
     ports_metrics_raw = get_metrics_azure_sdk(client, resource_id, "ports.used", start_time, end_time)
     ncu_metrics_raw = get_metrics_azure_sdk(client, resource_id, "ncu.provisioned", start_time, end_time)
-    network_metrics_raw = get_metrics_azure_sdk(client, resource_id, "system.interface.total_bytes", start_time, end_time)
+    data_processed_metrics_raw = get_metrics_azure_sdk(client, resource_id, "system.interface.total_bytes", start_time, end_time)
 
     waf_hourly = aggregate_hourly_data(waf_metrics_raw, "waf.enabled")
     ports_hourly = aggregate_hourly_data(ports_metrics_raw, "ports.used")
     ncu_hourly = aggregate_hourly_data(ncu_metrics_raw, "ncu.provisioned")
-    network_hourly = aggregate_hourly_data(network_metrics_raw, "system.interface.total_bytes")
+    data_processed_hourly = aggregate_hourly_data(data_processed_metrics_raw, "system.interface.total_bytes")
 
     cost_breakdown = []
 
-    if not (waf_hourly and ports_hourly and ncu_hourly and network_hourly):
+    if not (waf_hourly and ports_hourly and ncu_hourly and data_processed_hourly):
         raise Exception("No metric data available for the specified time range")
 
-    min_length = min(len(waf_hourly), len(ports_hourly), len(ncu_hourly), len(network_hourly))
-    print(f"📈 Processing {min_length} hours of data...")
-    
+    min_length = min(len(waf_hourly), len(ports_hourly), len(ncu_hourly), len(data_processed_hourly))    
     for i in range(min_length):
         timestamp = waf_hourly[i]['timestamp']
-        waf_enabled = waf_hourly[i]['value'] == 1  # 1 means WAF is enabled
+        waf_enabled = float(waf_hourly[i]['value']) == 1.0  # 1.0 means WAF is enabled
         ports_used = ports_hourly[i]['value']
         ncu_provisioned = ncu_hourly[i]['value']
-        total_bytes = network_hourly[i]['value']
+        total_bytes = data_processed_hourly[i]['value']
 
         # Convert total bytes to GB
         data_processed_gb = total_bytes / (1024 ** 3) if total_bytes else 0
 
-        # Check if deployment is active (both NCU and ports > 0 indicates active deployment)
-        deployment_active = ncu_provisioned > 0 or ports_used > 0
-        
-        # Cost components - only charge fixed costs if deployment is active
-        if deployment_active:
-            fixed_deployment_cost = pricing["fixed"]["NGINX"]
-            waf_cost = pricing["fixed"]["NGINX + WAF"] - fixed_deployment_cost if waf_enabled else 0
-        else:
-            fixed_deployment_cost = 0
-            waf_cost = 0
-        
+        base_deployment_cost = pricing["fixed"]["NGINX"]
+        waf_deployment_cost = pricing["fixed"]["NGINX + WAF"] - base_deployment_cost if waf_enabled else 0
         base_ncu_cost = ncu_provisioned * pricing["ncu"]["NGINX"]
         waf_ncu_cost = (ncu_provisioned * (pricing["ncu"]["NGINX + WAF"] - pricing["ncu"]["NGINX"])) if waf_enabled else 0
 
-        ports_cost = (max(ports_used - 5, 0) * pricing["ncu"]["NGINX"])  # Cost for ports > 5
+        ports_ncu_cost = (max(ports_used - 5, 0) * 2 * pricing["ncu"]["NGINX"])  # Cost for ports > 5
         data_processing_cost = data_processed_gb * pricing["data_processing"]
 
         # Total hourly cost
-        total_cost = fixed_deployment_cost + waf_cost + base_ncu_cost + waf_ncu_cost + ports_cost + data_processing_cost
+        total_cost = base_deployment_cost + waf_deployment_cost + base_ncu_cost + waf_ncu_cost + ports_ncu_cost + data_processing_cost
 
         # Append hourly cost breakdown
         cost_breakdown.append({
             "timestamp": timestamp,
-            "fixed_deployment_cost": round(fixed_deployment_cost, 6),
-            "waf_cost": round(waf_cost, 6),
+            "base_deployment_cost": round(base_deployment_cost, 6),
+            "waf_deployment_cost": round(waf_deployment_cost, 6),
             "base_ncu_cost": round(base_ncu_cost, 6),
             "waf_ncu_cost": round(waf_ncu_cost, 6),
-            "ports_cost": round(ports_cost, 6),
+            "ports_ncu_cost": round(ports_ncu_cost, 6),
             "data_processing_cost": round(data_processing_cost, 6),
             "total_cost": round(total_cost, 6)
         })
@@ -225,16 +207,13 @@ def parse_arguments():
                        help='Azure region where NGINX is deployed (e.g., eastus2, westus2)')
     parser.add_argument('--date-range', '-d', required=True,
                        help='Analysis period in ISO format: start/end (e.g., 2025-11-18T00:00:00Z/2025-11-19T23:59:59Z)')
-    
-    # Required tenant-id argument
     parser.add_argument('--tenant-id', '-t', required=True,
                        help='Azure AD Tenant ID (required for authentication)')
+    # Optional arguments
     parser.add_argument('--subscription-id', 
                        help='Azure Subscription ID (extracted from resource-id if not provided)')
     parser.add_argument('--output', '-o', default='nginxaas_cost_breakdown.csv',
                        help='Output CSV filename (default: nginxaas_cost_breakdown.csv)')
-    parser.add_argument('--verbose', '-v', action='store_true',
-                       help='Enable verbose debug output')
 
     return parser.parse_args()
 
@@ -250,36 +229,22 @@ def main():
         "date_range": args.date_range,
         "tenant_id": args.tenant_id,
         "output_file": args.output,
-        "verbose": args.verbose
     }
 
     # Validate required arguments
     if not config["resource_id"].startswith("/subscriptions/"):
-        print("❌ Error: Invalid resource ID format")
-        print("   Resource ID should start with /subscriptions/")
-        print("   Example: /subscriptions/xxx/resourceGroups/my-rg/providers/Nginx.NginxPlus/nginxDeployments/my-nginx")
+        print("Error: Invalid resource ID format.\nResource ID should start with /subscriptions/.\nExample: /subscriptions/xxx/resourceGroups/my-rg/providers/Nginx.NginxPlus/nginxDeployments/my-nginx")
         return 1
-    
+
     if not config["date_range"] or "/" not in config["date_range"]:
-        print("❌ Error: Invalid date range format")
-        print("   Use format: start/end (e.g., 2025-11-18T00:00:00Z/2025-11-19T23:59:59Z)")
+        print("Error: Invalid date range format.\nUse format: start/end (e.g., 2025-11-18T00:00:00Z/2025-11-19T23:59:59Z)")
         return 1
 
-    try:
-        print("🔧 Initializing NGINX for Azure Cost Analysis...")
-        print(f"📍 Location: {config['location']}")
-        print(f"📅 Date Range: {config['date_range']}")
-        print(f"🔗 Resource: {config['resource_id'].split('/')[-1]}")
-        print()
-        
-        # Authentication with Azure
-        print("🔐 Authenticating with Azure...")
-        
+    try: 
         # Use InteractiveBrowserCredential with required tenant_id
         credential = InteractiveBrowserCredential(
             tenant_id=config["tenant_id"]
         )
-        print(f"🌐 Using InteractiveBrowserCredential with tenant: {config['tenant_id']}")
 
         # Run the cost calculation
         result = calculate_cost_breakdown(
@@ -290,73 +255,39 @@ def main():
             config["subscription_id"]
         )
 
-        # Display summary statistics
-        total_hours = len(result)
-        total_cost = sum(entry["total_cost"] for entry in result)
-        avg_hourly_cost = total_cost / total_hours if total_hours > 0 else 0
-        
-        print("=" * 60)
-        print("📈 COST ANALYSIS SUMMARY")
-        print("=" * 60)
-        print(f"Total Analysis Period: {total_hours} hours")
-        print(f"Total Cost: ${total_cost:.2f}")
-        print()
-        
-        # Display detailed breakdown for first few hours
-        print("🕐 HOURLY COST BREAKDOWN (First 5 hours):")
-        print("-" * 60)
-        for i, entry in enumerate(result[:5]):
-            print(f"Hour {i+1} - {entry['timestamp']}")
-            print(f"  Fixed: ${entry['fixed_deployment_cost']:.3f} | WAF: ${entry['waf_cost']:.3f} | NCU: ${entry['base_ncu_cost']:.3f}")
-            print(f"  Ports: ${entry['ports_cost']:.3f} | Data: ${entry['data_processing_cost']:.3f} | Total: ${entry['total_cost']:.3f}")
-            print()
-        
-        if total_hours > 5:
-            print(f"... and {total_hours - 5} more hours")
-            print()
-        
         # Export to CSV
         export_to_csv(result, config["output_file"])
 
-        print("✅ Cost analysis completed successfully!")
+        print("Cost analysis completed successfully!")
         return 0
 
     except Exception as e:
         error_message = str(e)
-        print(f"❌ Error during cost analysis: {error_message}")
-        
+        print(f"Error during cost analysis: {error_message}")
         if "authorization" in error_message.lower() or "403" in error_message:
-            print("\n🔐 PERMISSIONS ERROR")
-            print("=" * 25)
-            print("Your Azure account needs access to read metrics from this NGINX resource.")
-            print("This typically requires 'Monitoring Reader' or 'Reader' role on the resource.")
+            print("\nPERMISSIONS ERROR\n" + "=" * 25 + "\nYour Azure account needs access to read metrics from this NGINX resource.\nThis typically requires 'Monitoring Reader' or 'Reader' role on the resource.")
         else:
-            print(f"\n💡 Please check:")
-            print("   • Your Azure permissions (Monitoring Reader role)")
-            print("   • That the resource ID is correct")
-            print("   • That the date range is within the last 30 days")
-            print("   • Try running 'az login' first for DefaultAzureCredential")
-        
+            print("\nPlease check:\n   - Your Azure permissions (Monitoring Reader role)\n   - That the resource ID is correct\n   - That the date range is within the last 30 days\n")
         return 1
 
 def export_to_csv(cost_breakdown, filename="nginx_cost_breakdown.csv"):
     """Export cost breakdown to CSV file."""
     import csv
 
     if not cost_breakdown:
-        print("⚠️  No data to export")
+        print("No data to export")
         return
 
     try:
         with open(filename, 'w', newline='') as csvfile:
             fieldnames = cost_breakdown[0].keys()
             header_mapping = {
                 "timestamp": "Timestamp",
-                "fixed_deployment_cost": "Base Fixed Cost ($USD)",
-                "waf_cost": "WAF Cost ($USD)",
+                "base_deployment_cost": "Base Deployment Cost ($USD)",
+                "waf_deployment_cost": "WAF Deployment Cost ($USD)",
                 "base_ncu_cost": "Base NCU Cost ($USD)",
                 "waf_ncu_cost": "WAF NCU Cost ($USD)",
-                "ports_cost": "Ports Cost ($USD)",
+                "ports_ncu_cost": "Ports NCU Cost ($USD)",
                 "data_processing_cost": "Data Processing Cost ($USD)",
                 "total_cost": "Total Cost ($USD)"
             }
@@ -372,11 +303,11 @@ def export_to_csv(cost_breakdown, filename="nginx_cost_breakdown.csv"):
 
             # Calculate and write summary totals
             total_hours = len(cost_breakdown)
-            total_fixed_deployment = sum(entry["fixed_deployment_cost"] for entry in cost_breakdown)
-            total_waf = sum(entry["waf_cost"] for entry in cost_breakdown)
+            total_fixed_deployment = sum(entry["base_deployment_cost"] for entry in cost_breakdown)
+            total_waf = sum(entry["waf_deployment_cost"] for entry in cost_breakdown)
             total_base_ncu = sum(entry["base_ncu_cost"] for entry in cost_breakdown)
             total_waf_ncu = sum(entry["waf_ncu_cost"] for entry in cost_breakdown)
-            total_ports = sum(entry["ports_cost"] for entry in cost_breakdown)
+            total_ports = sum(entry["ports_ncu_cost"] for entry in cost_breakdown)
             total_data_processing = sum(entry["data_processing_cost"] for entry in cost_breakdown)
             total_cost = sum(entry["total_cost"] for entry in cost_breakdown)
 
@@ -386,20 +317,20 @@ def export_to_csv(cost_breakdown, filename="nginx_cost_breakdown.csv"):
             # Add totals row with dollar signs
             totals_row = {
                 "timestamp": f"TOTALS ({total_hours} hours)",
-                "fixed_deployment_cost": f"${round(total_fixed_deployment, 4):.4f}",
-                "waf_cost": f"${round(total_waf, 4):.4f}",
+                "base_deployment_cost": f"${round(total_fixed_deployment, 4):.4f}",
+                "waf_deployment_cost": f"${round(total_waf, 4):.4f}",
                 "base_ncu_cost": f"${round(total_base_ncu, 4):.4f}",
                 "waf_ncu_cost": f"${round(total_waf_ncu, 4):.4f}",
-                "ports_cost": f"${round(total_ports, 4):.4f}",
+                "ports_ncu_cost": f"${round(total_ports, 4):.4f}",
                 "data_processing_cost": f"${round(total_data_processing, 4):.4f}",
                 "total_cost": f"${round(total_cost, 2):.2f}"
             }
             writer.writerow(totals_row)
 
-        print(f"✅ Cost breakdown exported to {filename}")
-        print(f"   📊 Summary: {total_hours} hours, Total cost: ${total_cost:.2f}")
+        print(f"Cost breakdown exported to {filename}")
+        print(f"Summary: {total_hours} hours, Total cost: ${total_cost:.2f}")
     except Exception as e:
-        print(f"❌ Error exporting to CSV: {e}")
+        print(f"Error exporting to CSV: {e}")
 
 if __name__ == "__main__":
     sys.exit(main())