Unmanaged memory not released after using SearchStreamAsync with asynchronous response callback in v24.1.0

[hetavi-chaudhary]

Describe the bug:

After upgrading to Google.Ads.GoogleAds v24.1.0, we started using the new asynchronous response callback of the SearchStreamAsync method.
However, we’ve observed that unmanaged memory usage is not released even after the entire process completes.

From memory profiling, it appears that the unmanaged memory is held by components within the Google.Ads.GoogleAds namespaces.

Steps to Reproduce:
Below is a simplified version of our usage pattern:

await googleAdsService.GetGoogleAdsDataByQuery(query, async (streamResponse) =>
{
    try
    {
        if (streamResponse?.Results is null) return;

       //Process each click detail record
        foreach (var clickDetail in streamResponse.Results)
        {
            // Your processing logic here
        }
    }
    catch (Exception e)
    {
        logger.LogError(e, "Error processing click details for date {@date}: {@errorMessage}", date, e.Message);
    }
});

After this method completes:

• All tasks and async operations have finished.
• The GC is invoked (automatically).
• Expected: Unmanaged memory should decrease.
• Actual: Unmanaged memory remains significantly high and does not decrease.

Client library version and API version:

• Client library version: Google.Ads.GoogleAds v24.1.0

Attached: Memory snapshots captured after the process completed.

[Raibaz]

I'm assuming you are calling the new SearchStreamAsync function returning a Task<SearchStreamStream>, that we added in the latest release, in your GetGoogleAdsDataByQuery.

Good catch; it is indeed not releasing unmanaged memory.

I'll implement a fix for the next release.

Thanks for spotting this!

[Raibaz]

While I work on a fix, a couple details occurred to me, which I cannot address because I don't have visibility on your GetGoogleAdsDataByQuery method:

1. The SearchStreamStream returned by SearchStreamAsync is not automatically disposed: you should ensure it is disposed of, for instance, by enclosing it in a using block:

using (SearchStreamStream stream = await googleAdsService.SearchStreamAsync(request, callback))
{
    // The 'await' completes only *after* all callbacks are done.
    // The 'stream' variable now holds the returned object.
    
    // You could, for example, inspect metadata from it:
    // Console.WriteLine($"Request ID: {stream.RequestId}");
}
// 'stream.Dispose()' is automatically called here, which releases all unmanaged memory.

2. The underlying network connection is meant to be reused across different API calls on the same GoogleAdsClient, which means that some memory will still not be released until the GoogleAdsClient is disposed of.

Does this make sense?

[hetavi-chaudhary]

Thanks for the suggestion. We’ve updated our code to use the using statement as recommended, ensuring that the SearchStreamStream returned by SearchStreamAsync is properly disposed.

However, we haven’t noticed any significant difference in unmanaged memory release after making this change. For reference, here’s the relevant portion of our code:

using (await googleAdsService.GetGoogleAdsDataByQuery(query, async (streamResponse) =>
{
    try
    {
        if (streamResponse?.Results is null) return;

        foreach (var clickDetail in streamResponse.Results)
        {
            // Add click detail to repository
        }
        // Save changes to repository
        // Clear repository context
    }
    catch (Exception e)
    {
        logger.LogError(e, "Error processing click details for date {@date}: {@errorMessage}", date, e.Message);
    }
})) { }

And here’s our GetGoogleAdsDataByQuery method for context:

public async Task<GoogleAdsServiceClient.SearchStreamStream> GetGoogleAdsDataByQuery(
    string query,
    Func<SearchGoogleAdsStreamResponse, Task> responseCallback)
{
    GoogleAdsClient googleAdsClient = new(_googleAdsConfig);
    var googleAdsService = googleAdsClient.GetService(GoogleAdsServiceVersion.GoogleAdsService);

    var request = new SearchGoogleAdsStreamRequest
    {
        CustomerId = _googleAdsConfiguration.StandardCustomerId,
        Query = query,
        SummaryRowSetting = SummaryRowSettingEnum.Types.SummaryRowSetting.NoSummaryRow
    };

    return await googleAdsService.SearchStreamAsync(request, responseCallback);
}

[Raibaz]

Ok, I think I may have a solution: can you please try reusing the same googleAdsService across different calls to GetGoogleAdsDataByQuery?

It should look something like this:

public async Task<GoogleAdsServiceClient.SearchStreamStream> GetGoogleAdsDataByQuery(
    string query,
    GoogleAdsServiceClient googleAdsService,
    Func<SearchGoogleAdsStreamResponse, Task> responseCallback)
{
    var request = new SearchGoogleAdsStreamRequest
    {
        CustomerId = _googleAdsConfiguration.StandardCustomerId,
        Query = query,
        SummaryRowSetting = SummaryRowSettingEnum.Types.SummaryRowSetting.NoSummaryRow
    };

    return await googleAdsService.SearchStreamAsync(request, responseCallback);
}

As I was saying in my first comment, the underlying network connection is going to be reused across different API calls on the same GoogleAdsClient; I wonder if instantiating a new GoogleAdsClient on each call to GetGoogleAdsDataByQuery is preventing you from reusing network connections.

[hetavi-chaudhary]

We actually already tried this approach — reusing the same GoogleAdsServiceClient instance across multiple calls to GetGoogleAdsDataByQuery. Unfortunately, we didn’t observe any difference in behavior or memory usage; the issue persisted even when using a shared instance.

[Zweitze]

I am using Google.Ads.GoogleAds.V19.GoogleAdsServiceClient.SearchStreamAsync() which was also present in the library v22.1.0. Comparing the implementation with library v24.1.0, I see no difference.
In fact, I have been using the Async version since February 2023, with API version v13.

However @Raibaz wrote on 27th October 2025:

I'm assuming you are calling the new SearchStreamAsync function returning a Task<SearchStreamStream>, that we added in the latest release, in your GetGoogleAdsDataByQuery.

Good catch; it is indeed not releasing unmanaged memory.

I'll implement a fix for the next release.

Thanks for spotting this!

So in 2023 I used a method that was added in 2025. What am I missing? Is this issue about a SearchStreamAsync method in a different class? If so, which?

Note: Nevertheless I'm happy to have seen this issue, as I learnt that class SearchStreamStream implements IDisposable and should therefore be disposed.