How to Monitor Azure Table Storage Size and Implement Auto Cleanup

Hello Dharmesh Joshi, it sounds like you want two things:

1. A way to see how much space each of your Azure Table Storage tables is using (in GB) via C#.
2. An automated “purge-old-data” job that deletes entities older than X days.

Below is one approach you can take, along with sample C# code and relevant docs.

1. Monitor table storage size Unfortunately, Azure Monitor today only exposes “UsedCapacity” at the storage account level (i.e. total for all tables), not broken down by table. If you can live with account-wide metrics, you can pull that in C# via the Azure Monitor Query SDK:

      using Azure.Identity;
   

using Azure.Monitor.Query; using Azure.Monitor.Query.Models;

// 1) Authenticate var credential = new DefaultAzureCredential();

// 2) Create client var metricsClient = new MetricsQueryClient(credential);

// 3) Resource ID of your storage account/Table service string resourceId = "/subscriptions/{subId}/resourceGroups/{rg}/providers/Microsoft.Storage/storageAccounts/{accountName}/tableServices/default";

// 4) Query UsedCapacity over last hour Response<MetricsQueryResult> response = await metricsClient.QueryResourceAsync( resourceId, new[] { "UsedCapacity" }, new MetricsQueryOptions { TimeSpan = TimeSpan.FromHours(1), Interval = TimeSpan.FromHours(1), Aggregations = { MetricAggregationType.Total } });

// 5) Read out the metric var metric = response.Value.Metrics.FirstOrDefault(); var usageBytes = metric.TimeSeries[0].Data.Last().Total ?? 0; var usageGB = usageBytes / 1024.0 / 1024.0 / 1024.0; Console.WriteLine($"Total Table Storage used: {usageGB:F2} GB");

   
   If you *really* need per-table breakdown, you have a couple of workarounds:
   
      - Enable Storage Analytics (resource logs) for Table service, send them to Log Analytics, then run Kusto queries grouping by `TableName` and summing the `RequestSize` or `Egress` fields.
      
         - Maintain your own running count/byte-count whenever you write entities (e.g. store entity-size metadata in a side table).
         
         Auto-cleanup of old entities
         
         The easiest way is to spin up an Azure Function (or a WebJob/Console App) with a Timer Trigger. Below is a simple example that loops through entities older than `cutoff` and deletes them:
         
         ```powershell
         using Azure;
using Azure.Data.Tables;

public static async Task PurgeOldDataAsync(string storageConnectionString, string tableName, TimeSpan maxAge)
{
    // 1) Get a client for your table
    var serviceClient = new TableServiceClient(storageConnectionString);
    var tableClient = serviceClient.GetTableClient(tableName);

    // 2) Build a filter on the built-in Timestamp property
    var cutoff = DateTimeOffset.UtcNow - maxAge;
    string filter = TableClient.CreateQueryFilter($"Timestamp lt {cutoff}");

    // 3) Query matching entities
    await foreach (Page<TableEntity> page in tableClient.QueryAsync<TableEntity>(filter).AsPages(pageSizeHint: 100))
    {
        // Batch-delete up to 100 at a time
        var batch = new List<TableTransactionAction>();
        foreach (var entity in page.Values)
        {
            batch.Add(new TableTransactionAction(TableTransactionActionType.Delete, entity));
        }

        if (batch.Any())
        {
            await tableClient.SubmitTransactionAsync(batch);
        }
    }
}
         ```
         
         You can call `PurgeOldDataAsync(...)` from a Function with a cron schedule (e.g. every night) and pass in your desired TTL (30 days, 100 days, whatever).
         
[https://learn.microsoft.com/en-us/samples/azure-samples/monitor-dotnet-metrics-api/monitor-dotnet-metrics-api/](https://learn.microsoft.com/en-us/samples/azure-samples/monitor-dotnet-metrics-api/monitor-dotnet-metrics-api/)  
[https://learn.microsoft.com/en-us/azure/storage/tables/monitor-table-storage?tabs=azure-portal](https://learn.microsoft.com/en-us/azure/storage/tables/monitor-table-storage?tabs=azure-portal)  
  
Hope that helps!

In regard to the following comment, how do we set up sending data to analytics, and how often would this occur? Is it possible to implement this in a C# Function App that runs once per day?

Enable Storage Analytics (resource logs) for Table service, send them to Log Analytics, then run Kusto queries grouping by TableName and summing the RequestSize or Egress fields.

Hello Dharmesh Joshi, To get per-table visibility, you first need to enable Table Storage diagnostic logs and send them to Log Analytics. This is not something done in C# directly — it is configured once at the storage account level in Azure.

You can set this up by going to your Storage Account → Monitoring → Diagnostic settings, then enable logs for Table service and select Send to Log Analytics workspace. Once enabled, Azure will continuously send request telemetry (reads/writes/deletes, size indicators, etc.) to the workspace. The data typically starts appearing within a few minutes after configuration.

After logs are flowing, you can query usage patterns using KQL in Log Analytics. From there, you can build automation.

Regarding automation:

Yes — you can absolutely implement this as a C# Azure Function that runs once per day. A common pattern is:

• Function runs daily (Timer Trigger)
• Queries entities older than your retention threshold (for example 30 or 100 days)
• Deletes them in batches
• Optionally logs deletion metrics

This is currently the recommended approach for lifecycle cleanup in Table Storage, since Table Storage does not have built-in retention policies like Blob lifecycle management.

https://learn.microsoft.com/en-gb/azure/azure-functions/functions-bindings-timer?tabs=python-v2%2Cisolated-process%2Cnodejs-v4&pivots=programming-language-csharp
https://learn.microsoft.com/en-gb/azure/storage/tables/monitor-table-storage?tabs=azure-portal

Thanks, I will give this a try, but would it be for tables that are currently being written to or also older tables that might not being used?

Also once logs are being sent to Log Analytics workspace, can i also observe the information on the portal?

Hello Dharmesh Joshi, This will work for both active and old tables. The cleanup is based on the Timestamp, so it will delete only data older than your defined retention (like 30/100 days), regardless of whether the table is still in use.

Also, once logs are sent to Log Analytics, you can view everything directly in the Azure portal using KQL queries.

And yes - running this as a daily C# Function App is a good and recommended approach