What information can be handled by a custom propagator in the OtelAgent?

[shinozakisatoshi11]

I am considering customizing the OtelAgent, and therefore, I was organizing the information that can be handled in DemoPropagator.java. I referred to this link and was able to obtain header information from the carrier, but I found it difficult to work with the request path. Is this not possible? Also, handling the request body is not possible, right?

java

getter.keys(carrier).forEach(key -> {
    Object value = getter.get(carrier, key);
    logger.log(Level.INFO, "Key: {0}, Value: {1}", new Object[]{key, value});
});

For reference: DemoPropagator.java example

[laurit]

but I found it difficult to work with the request path. Is this not possible? Also, handling the request body is not possible, right?

needing to use request path and body in the propagator is unusual. Please elaborate on what you are trying to achieve.

[shinozakisatoshi11]

thank
I was thinking it would be great if we could hash a unique ID that exists within the contents of the path or body, and set it as the trace ID. This would allow us to link multiple APIs more effectively than automatic numbering.

It looked like this in the header items. Additionally, I would like to know if there are things I should be aware of or any considerations I might have overlooked.

package com.tsp.poc.propagator;

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
import java.util.Collections;
import java.util.HexFormat;
import java.util.List;
import io.opentelemetry.api.trace.Span;
import io.opentelemetry.api.trace.SpanContext;
import io.opentelemetry.api.trace.TraceFlags;
import io.opentelemetry.api.trace.TraceState;
import io.opentelemetry.context.Context;
import io.opentelemetry.context.propagation.TextMapGetter;
import io.opentelemetry.context.propagation.TextMapPropagator;
import io.opentelemetry.context.propagation.TextMapSetter;


public class CustomPropagator implements TextMapPropagator {
  private static final String TRACE_FIELD = "header-Id";
  private static final String ATTR_FIELD = "header-Id";
  private static final String PROPAGATION_KEY = "header.id";
  private static final String ANY_SPAN_ID = "8d78a1a12ad9c6c5";
  private static final TraceFlags TRACE_FLAG = TraceFlags.fromByte((byte) 0x01);
  private static final List<String> FIELDS =
      Collections.unmodifiableList(Arrays.asList(TRACE_FIELD, ATTR_FIELD));

  @Override
  public List<String> fields() {
    return FIELDS;
    // return Collections.singletonList(ATTR_FIELD);
    // return Collections.emptyList();
  }

  @Override
  public <C> void inject(Context context, C carrier, TextMapSetter<C> setter) {
    
    // String propagation = context.get(PROPAGATION_KEY);
    // if (propagation != null) {
    //     setter.set(carrier, ATTR_FIELD, propagation);
    // }
  }

  @Override
  public <C> Context extract(Context context, C carrier, TextMapGetter<C> getter) {
    if (context == null) {
      return Context.root();
    }
    if (getter == null) {
      return context;
    }

    SpanContext spanContext = extractImplCustom(carrier, getter);
    if (!spanContext.isValid()) {
      return context;
    }

    Context ctx = context.with(Span.wrap(spanContext));
    return ctx;
  }

  private static <C> SpanContext extractImplCustom(C carrier, TextMapGetter<C> getter) {
    String headerId = getter.get(carrier, TRACE_FIELD);
    if (headerId != null) {
        return  extractContextFromTraceId(format(headerId));
    }
    return SpanContext.getInvalid();
  }
  private static SpanContext extractContextFromTraceId(String traceId) {
    return SpanContext.createFromRemoteParent(traceId, ANY_SPAN_ID, TRACE_FLAG, TraceState.getDefault());
  }
  private static String format(String headerId) {
    try{
      MessageDigest sha256 = MessageDigest.getInstance("SHA-256");
			byte[] sha256Byte = sha256.digest(headerId.getBytes());

			HexFormat hex = HexFormat.of().withLowerCase();
			String traceId = hex.formatHex(sha256Byte);
      return traceId.substring(0, 32);
    } catch (NoSuchAlgorithmException e) {
      return headerId;
    }
  }

}

[laurit]

I would advice you against attempting this unless you really understand what you are doing as otherwise you'll end up just wasting a bunch of time. There isn't anything in the propagator that would prevent you from using something from the request path instead of a header. The actual access to the carrier is implemented in TextMapGetter so if you wish to use something else besides headers you'd need to replace the TextMapGetter implementation which mean you'd need to replace the instrumentations that the agent uses with your own instrumentations. So if you wish to read trace id from incoming request path you'd firstly need an instrumentation that exposes that information. Inside your TextMapGetter you could combine the data to look like a w3c context propagation header then you wouldn't need a custom propagator at all or you could expose it in a custom format that you could read with your custom propagator.