Datadog .NET APM Tracer

Duck chaining allows you to interact with properties or methods that return non-public types by automatically wrapping those return values in a new duck-type proxy. This enables deep access into the internals of an object hierarchy.

To implement duck chaining, define proxy interfaces for both the parent and the nested type. When the parent proxy's property returns the nested type, the library will automatically wrap it in the nested proxy interface.

Example

If MyHandler has an internal property Configuration of type MyHandlerConfiguration:

public class MyHandler 
{
    public string Name { get; set; } 
    internal MyHandlerConfiguration Configuration { get; }
}

internal class MyHandlerConfiguration 
{
    public int MaxConnections { get; set; }
}

Define your proxies like this:

public interface IProxyMyHandler
{
    string Name { get; set; }
    IProxyMyHandlerConfiguration Configuration { get; }
}

public interface IProxyMyHandlerConfiguration
{
    int MaxConnections { get; set; }
}

Calling proxyMyHandler.Configuration will return an instance of IProxyMyHandlerConfiguration, allowing you to access MaxConnections even though the underlying type is internal.

When troubleshooting Datadog instrumentation in Azure Functions, it is critical to understand how log files are managed:

• Append-only & Persistent: Log files are not cleared on deployment. New entries are appended to the end, while old entries from previous versions remain at the beginning. Always filter by timestamp instead of using head or tail.
• Host vs. Worker Processes (Isolated Mode):
  • Host Process: Manages triggers and scaling. Log pattern: dotnet-tracer-managed-Microsoft.Azure.WebJobs.Script.WebHost-{pid}.log.
  • Worker Process: Executes your code. Log pattern: dotnet-tracer-managed-dotnet-{pid}.log. Multiple worker processes (different PIDs) may exist.
• Worker Lifecycle: Worker processes restart on deployment but may reuse the same PID (especially in Linux containers). This means a single log file can contain entries spanning multiple deployments and process lifetimes.

Duck-chaining occurs when a duck-type proxy uses another duck-type proxy as a property.

Critical Warning: Unlike direct duck-proxy creation (which throws DuckTypeException when the proxy is created), duck-chained proxies throw exceptions only when the property is accessed.

If IProxyRoot.Configuration is a duck-chained property and the underlying configuration object is invalid, the exception will not trigger during someObject.DuckType<IProxyRoot>(), but rather when you call proxy.Configuration.

public interface IProxyMyHandler
{
    string Name { get; set; }
    IProxyMyHandlerConfiguration Configuration { get; }
}

public int GetMaxConnections(object someObject)
{
    // This succeeds even if Configuration is invalid
    var proxy = someObject.DuckType<IProxyMyHandler>();
 
    // ⚠ Exception is thrown HERE if Configuration is invalid
    var config = proxy.Configuration;
    
    return config.MaxConnections;
}

For components with large internal structures (e.g., ManagedThreadList, FrameStore, DebugInfoStore, HeapSnapshotManager), traversing all items in GetMemorySize() can be expensive. Use incremental tracking to keep modifications $O(1)$.

Implementation Pattern

1. Add a cached size field (use std::atomic<size_t> for thread safety): mutable std::atomic<size_t> _cachedItemsSize;

2. Update size during modifications:

   • In AddItem(): Calculate the new item's size and use _cachedItemsSize.fetch_add(itemSize, std::memory_order_relaxed);
   • In RemoveItem(): Calculate the item's size and use _cachedItemsSize.fetch_sub(itemSize, std::memory_order_relaxed); before erasing.
   • In Clear(): Reset _cachedItemsSize.store(0, std::memory_order_relaxed);

3. Calculate total in GetMemorySize(): Combine the constant container overhead (calculated on-demand) with the cached items size:

size_t MyComponent::GetMemorySize() const {
    std::lock_guard<std::mutex> lock(_mutex);

    size_t totalSize = sizeof(MyComponent);

    // Calculate container overhead on-demand (cheap, no iteration)
    totalSize += _items.bucket_count() * (sizeof(Key) + sizeof(Value) + sizeof(void*));

    // Add cached items size (updated incrementally at add/remove time)
    totalSize += _cachedItemsSize.load(std::memory_order_relaxed);

    return totalSize;
}

When to use

• Use when: Components have large collections (>100 items) or GetMemorySize() is called frequently (e.g., for metrics).
• Avoid when: Collections are small (<50 items) where traversal is cheap, or if the structure is rarely modified and rarely queried.