Program.cs


namespace azure_usage_report
{
 using System;
 using System.Threading.Tasks;
 using System.Linq;
 using System.Collections.Generic;
 using Newtonsoft.Json;
 using Microsoft.Extensions.CommandLineUtils;
 using System.Text.RegularExpressions;
 using ConsoleTables;
 using System.Net;
 using System.Threading;

 class Program
 {
 static void Main(params string[] args)
 {
 ThreadPool.SetMinThreads(96, 24); 
 ServicePointManager.DefaultConnectionLimit = Environment.ProcessorCount * 64;

 var app = new CommandLineApplication();

 app.Name = "azusage";
 app.FullName = "Azure Subscription Usage Report";

 app.HelpOption("-?|-h|--help");

 var tenantId = app.Option("-t|--tenant", "The Azure tenant Id to sign in.", CommandOptionType.SingleValue);
 var clientId = app.Option("-c|--client", "Service principal client Id for accessing Azure subscriptions.", CommandOptionType.SingleValue);
 var clientSecret = app.Option("-s|--secret", "Service principal client secret for accessing Azure subscriptions.", CommandOptionType.SingleValue);
 var outputOption = app.Option("-o|--output", "Output format: Json, Table, Markdown or Csv.", CommandOptionType.SingleValue);
 var titleOption = app.Option("--title", "Table and Markdown output title. Ignored in JSON output.", CommandOptionType.SingleValue);
 var usageOption = app.Option("-n|--usage-name", "Show only specified usages, e.g. cores. Can specify multiple values.", CommandOptionType.MultipleValue);
 var subscriptionFilterOption = app.Option("-p|--subscription-pattern", "Show only specified subscriptions, support regex. Can specify multiple values.", CommandOptionType.MultipleValue);
 var accessTokenOption = app.Option("--access-token", "Specify Azure Resource Manager access token directly. Service principal will be ignored in this case.", CommandOptionType.SingleValue);

 app.Command("list", (command) =>
 {
 command.Description = "Lists subscription usages by individual subscriptions.";
 command.HelpOption("-?|-h|--help");

 command.Options.Add(clientId);
 command.Options.Add(clientSecret);
 command.Options.Add(tenantId);
 command.Options.Add(outputOption);
 command.Options.Add(usageOption);
 command.Options.Add(subscriptionFilterOption);
 command.Options.Add(accessTokenOption);

 command.OnExecute(() =>
 {
 if (!accessTokenOption.HasValue() && !(tenantId.HasValue() && clientId.HasValue() && clientSecret.HasValue()))
 {
 Console.WriteLine(app.GetHelpText());
 return 1;
 }

 var outputFormatStr = outputOption.HasValue()
 ? outputOption.Value()
 : OutputFormat.Json.ToString();

 OutputFormat format;
 if (!Enum.TryParse<OutputFormat>(outputFormatStr, ignoreCase: true, result: out format))
 {
 Console.WriteLine(outputFormatStr);
 Console.WriteLine(app.GetHelpText());
 return 1;
 }

 if (format != OutputFormat.Json)
 {
 Console.WriteLine("List usage only support JSON output.");
 return 1;
 }

 var subscriptionPattern = subscriptionFilterOption.HasValue()
 ? new Regex(subscriptionFilterOption.Value(), RegexOptions.Compiled | RegexOptions.IgnoreCase, TimeSpan.FromSeconds(5))
 : new Regex(".*", RegexOptions.Compiled | RegexOptions.IgnoreCase, TimeSpan.FromSeconds(5));

 var filter = usageOption.HasValue() ? usageOption.Values.ToArray() : new string[0];

 var accessToken = Program.GetAccessToken(accessTokenOption, tenantId, clientId, clientSecret);
 if (string.IsNullOrEmpty(accessToken))
 {
 Console.WriteLine("Failed to get access token.");
 return 1;
 }

 var usages = Program.GetUsage(accessToken, filter, subscriptionPattern).Result;
 Console.WriteLine(JsonConvert.SerializeObject(usages, Formatting.Indented));

 return 0;
 });
 });

 app.Command("summary", (command) =>
 {
 command.Description = "Summarize subscription usages by name groups.";
 command.HelpOption("-?|-h|--help");

 command.Options.Add(clientId);
 command.Options.Add(clientSecret);
 command.Options.Add(tenantId);
 command.Options.Add(outputOption);
 command.Options.Add(usageOption);
 command.Options.Add(subscriptionFilterOption);
 command.Options.Add(titleOption);
 command.Options.Add(accessTokenOption);

 command.OnExecute(() =>
 {
 if (!accessTokenOption.HasValue() && !(tenantId.HasValue() && clientId.HasValue() && clientSecret.HasValue()))
 {
 Console.WriteLine(app.GetHelpText());
 return 1;
 }

 var outputFormatStr = outputOption.HasValue()
 ? outputOption.Value()
 : OutputFormat.Table.ToString();

 OutputFormat format;
 if (!Enum.TryParse<OutputFormat>(outputFormatStr, ignoreCase: true, result: out format))
 {
 Console.WriteLine(outputFormatStr);
 Console.WriteLine(app.GetHelpText());
 return 1;
 }

 if (format != OutputFormat.Table 
 && format != OutputFormat.Markdown
 && format != OutputFormat.Csv)
 {
 Console.WriteLine("Summary usage only support table, markdown or csv output.");
 return 1;
 }

 var subscriptionPattern = subscriptionFilterOption.HasValue()
 ? new Regex(subscriptionFilterOption.Value(), RegexOptions.Compiled | RegexOptions.IgnoreCase, TimeSpan.FromSeconds(5))
 : new Regex(".*", RegexOptions.Compiled | RegexOptions.IgnoreCase, TimeSpan.FromSeconds(5));

 var specifiedUsages = usageOption.HasValue() ? usageOption.Values.ToArray() : new string[0];

 var accessToken = Program.GetAccessToken(accessTokenOption, tenantId, clientId, clientSecret);
 if (string.IsNullOrEmpty(accessToken))
 {
 Console.WriteLine("Failed to get access token.");
 return 1;
 }

 var usages = Program.GetUsage(
 accessToken: accessToken, 
 specifiedUsages: specifiedUsages,
 subscriptionPattern: subscriptionPattern).Result;

 if (!usages.Any())
 {
 Console.WriteLine("No usage reported.");
 return 0;
 }

 var locationGroupedUsages = usages
 .SelectMany(usage => usage.Usages)
 .GroupBy(u => u.Location, StringComparer.OrdinalIgnoreCase);

 var regionalUsages = new List<RegionalUsage>();
 foreach (var lgusage in locationGroupedUsages)
 {
 foreach (var locationResourceGroup in lgusage.GroupBy(usage => usage.Name.Value, StringComparer.OrdinalIgnoreCase))
 {
 regionalUsages.Add(new RegionalUsage
 {
 Location = lgusage.Key,
 Resource = locationResourceGroup.Key,
 Current = locationResourceGroup.Select(usage => usage.CurrentValue).Sum(),
 Limit = locationResourceGroup.Select(usage => usage.Limit).Sum()
 });
 }
 }

 var title = titleOption.HasValue() ? titleOption.Value() : null;
 var output = format == OutputFormat.Csv
 ? CsvFormater.FormatSummary(regionalUsages.ToArray())
 : TableFormater.FormatSummary(format, title, regionalUsages.ToArray());

 Console.WriteLine(output);
 return 0;
 });
 });

 app.OnExecute(() =>
 {
 Console.WriteLine("No options specified!");
 Console.WriteLine(app.GetHelpText());
 return 0;
 });

 app.Execute(args);
 }

 private static string GetAccessToken(CommandOption accessTokenOption, CommandOption tenantIdOption, CommandOption clientIdOption, CommandOption clientSecretOption)
 {
 return accessTokenOption.HasValue()
 ? accessTokenOption.Value()
 : AuthUtil.GetToken(tenantIdOption.Value(), clientIdOption.Value(), clientSecretOption.Value())?.AccessToken;
 }

 static async Task<SubscriptionUsage[]> GetUsage(string accessToken, string[] specifiedUsages, Regex subscriptionPattern)
 {
 var subscriptionsProvider = new SubscriptionsDataProvider();
 var usageProvider = new UsageDataProvider();
 var locationsProvider = new LocationsDataProvider();

 var locations = (await locationsProvider.GetLocations(accessToken)).Select(l => l.Name).ToArray();
 var subscriptions = await subscriptionsProvider.GetSubscriptions(accessToken);
 var subscriptionUsages = new List<SubscriptionUsage>();

 foreach (var sub in subscriptions)
 {
 if (!subscriptionPattern.IsMatch(sub.DisplayName))
 {
 continue;
 }

 var subscriptionUsage = new SubscriptionUsage() { Subscription = sub, Usages = new Usage[0] };
 var tasks = locations.Select(l => Program.GetRegionalUsage(accessToken, sub.SubscriptionId, l)).ToArray();
 await Task.WhenAll(tasks);

 var regionalUsages = tasks.Select(task => task.Result).ToArray();

 foreach (var regionalUsage in regionalUsages)
 {
 var reportUsages = regionalUsage.Value
 .Where(u => (!specifiedUsages.Any() && u.CurrentValue != 0) || specifiedUsages.Any(f => u.Name.Value.Equals(f, StringComparison.OrdinalIgnoreCase)))
 .ToArray();

 Array.ForEach(reportUsages, u => u.Location = regionalUsage.Key);

 subscriptionUsage.Usages = subscriptionUsage.Usages.Concat(reportUsages).ToArray();
 }
 subscriptionUsages.Add(subscriptionUsage);
 }

 return subscriptionUsages.ToArray();
 }

 static async Task<KeyValuePair<string, Usage[]>> GetRegionalUsage(string accessToken, string subscriptionId, string location)
 {
 var usageProvider = new UsageDataProvider();
 var usages = await usageProvider.GetComputeUsage(accessToken, subscriptionId, location);

 return KeyValuePair.Create(location, usages.Where(u => u.CurrentValue != 0).ToArray());
 }
 }
}