TraceIdRatioBased sampler with AlwaysOn for Error

[glucaci]

There is any way for example to use a TraceIdRatioBased with 0.5 but to always sample Activity with Error or Unset status?

For example I have an worker which is creating a lot of activates and I need only 50% of the successful ones but I want 100% of the error ones.

I think out of the box there is no way, because sampling is processed on creation of the activity, but I thought to an approach where the activity could be dropped in a custom processor.

internal class SamplerProcessor : BaseProcessor<Activity>
{
    private readonly Sampler _sampler =
        new ParentBasedSampler(new TraceIdRatioBasedSampler(0.5));

    public override void OnEnd(Activity data)
    {
        if (data.Status != ActivityStatusCode.Ok)
        {
            return;
        }

        var samplingParameters = new SamplingParameters(
            data.Context,
            data.TraceId,
            data.OperationName,
            data.Kind,
            data.TagObjects,
            data.Links);

        SamplingResult shouldSample = _sampler.ShouldSample(samplingParameters);

        if (shouldSample.Decision == SamplingDecision.Drop)
        {
            data.ActivityTraceFlags = ActivityTraceFlags.None;
        }
    }
}

Would this be a reliable solution?

Thanks!

[cijothomas]

The best way to achieve "tail based" sampling is to do it at collector level. There might already be some collector extensions for this.

[glucaci]

Yes, I found something, thanks!
https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/processor/tailsamplingprocessor

[glucaci]

What will be the pros to have it on the collector level?

I can see some cons:

• more application load because the activity will be exported
• more traffic to the collector
• must deploy collector loadbalancer
• if I need tail-based sampling only to some services, collector config must include filters with service.name

Thanks in advance for your thoughts.

[glucaci]

To have more context why I'm more for the application level tail-based processor is that we want to create a internal nuget package for all our services and to let the sampling decision to the team that develops that service.