reimplement metrics-tracing-tags

inspectIT · Dec 8, 2023 · d0a1e6c · d0a1e6c
1 parent 36a8732
commit d0a1e6c
Show file tree

Hide file tree

Showing 6 changed files with 349 additions and 11 deletions.
diff --git a/...lot-config/src/main/java/rocks/inspectit/ocelot/config/model/tracing/TracingSettings.java b/...lot-config/src/main/java/rocks/inspectit/ocelot/config/model/tracing/TracingSettings.java
@@ -54,6 +54,12 @@ public enum AddCommonTags {
     @NotNull
     private AddCommonTags addCommonTags;
 
+    /**
+     * If enabled, metric tags will be added as attributes to tracing within the same rule
+     */
+    @NotNull
+    private boolean addMetricTags;
+
     /**
      * Settings for automatic tracing (stack trace sampling)
      */
@@ -79,7 +85,7 @@ public enum AddCommonTags {
     private long scheduleDelayMillis = 5000;
 
     /**
-     * I enabled 64 Bit Trace Ids are used instead of the default 128 Bit.
+     * If enabled, 64 Bit Trace Ids are used instead of the default 128 Bit.
      */
     private boolean use64BitTraceIds = false;
 }
diff --git a/inspectit-ocelot-config/src/main/resources/rocks/inspectit/ocelot/config/default/basics.yml b/inspectit-ocelot-config/src/main/resources/rocks/inspectit/ocelot/config/default/basics.yml
@@ -36,6 +36,8 @@ inspectit:
     # defines when to add common tags as attributes to spans
     # options are: NEVER, ON_GLOBAL_ROOT, ON_LOCAL_ROOT, ALWAYS
     add-common-tags: ON_LOCAL_ROOT
+    # if enabled, metric tags will be added as attributes to tracing within the same rule
+    add-metric-tags: true
     # settings regarding automatic tracing (stack-trace-sampling)
     auto-tracing:
       frequency: 50ms

diff --git a/...e/src/main/java/rocks/inspectit/ocelot/core/instrumentation/hook/MethodHookGenerator.java b/...e/src/main/java/rocks/inspectit/ocelot/core/instrumentation/hook/MethodHookGenerator.java
@@ -109,7 +109,7 @@ public MethodHook buildHook(Class<?> declaringClass, MethodDescription method, M
         builder.exitActions(buildActionCalls(config.getPreExitActions(), methodInfo));
         builder.exitActions(buildActionCalls(config.getExitActions(), methodInfo));
         if (tracingSettings != null) {
-            List<IHookAction> actions = buildTracingExitActions(tracingSettings);
+            List<IHookAction> actions = buildTracingExitActions(config);
             if (isTracingInternalActions() && config.isTraceExitHook()) {
                 actions = wrapActionsWithTracing(actions);
             }
@@ -190,7 +190,8 @@ private void configureSampling(RuleTracingSettings tracing, ContinueOrStartSpanA
     }
 
     @VisibleForTesting
-    List<IHookAction> buildTracingExitActions(RuleTracingSettings tracing) {
+    List<IHookAction> buildTracingExitActions(MethodHookConfiguration config) {
+        RuleTracingSettings tracing = config.getTracing();
         val result = new ArrayList<IHookAction>();
 
         boolean isSpanStartedOrContinued = tracing.getStartSpan() || StringUtils.isNotBlank(tracing.getContinueSpan());
@@ -201,10 +202,24 @@ List<IHookAction> buildTracingExitActions(RuleTracingSettings tracing) {
                 result.add(new SetSpanStatusAction(accessor));
             }
 
-            val attributes = tracing.getAttributes();
-            if (!attributes.isEmpty()) {
+            Map<String, String> tracingAttributes = tracing.getAttributes();
+            Map<String, String> attributes = tracingAttributes;
+            Map<String, String> constantAttributes = new HashMap<>();
+
+            if(addMetricsToTracing()) {
+                Collection<MetricRecordingSettings> metrics = config.getMetrics();
+                constantAttributes = collectMetricConstantTags(metrics);
+                attributes = collectMetricDataTags(metrics);
+                // write tracing attributes after metric tags, to allow overwriting of metric tags
+                attributes.putAll(tracingAttributes);
+            }
+
+            if (!attributes.isEmpty() || !constantAttributes.isEmpty()) {
                 Map<String, VariableAccessor> attributeAccessors = new HashMap<>();
+                constantAttributes.forEach((attribute, constant) -> attributeAccessors.put(attribute, variableAccessorFactory.getConstantAccessor(constant)));
+                // if necessary, overwrite constant attributes
                 attributes.forEach((attribute, variable) -> attributeAccessors.put(attribute, variableAccessorFactory.getVariableAccessor(variable)));
+
                 IHookAction endTraceAction = new WriteSpanAttributesAction(attributeAccessors, obfuscationManager.obfuscatorySupplier());
                 IHookAction actionWithConditions = ConditionalHookAction.wrapWithConditionChecks(tracing.getAttributeConditions(), endTraceAction, variableAccessorFactory);
                 result.add(actionWithConditions);
@@ -219,13 +234,24 @@ List<IHookAction> buildTracingExitActions(RuleTracingSettings tracing) {
         return result;
     }
 
+    private Map<String, String> collectMetricDataTags(Collection<MetricRecordingSettings> metrics) {
+        Map<String, String> dataTags = new HashMap<>();
+        metrics.forEach(metric -> dataTags.putAll(metric.getDataTags()));
+        return dataTags;
+    }
+
+    private Map<String, String> collectMetricConstantTags(Collection<MetricRecordingSettings> metrics) {
+        Map<String, String> constantTags = new HashMap<>();
+        metrics.forEach(metric -> constantTags.putAll(metric.getConstantTags()));
+        return constantTags;
+    }
+
     private Optional<IHookAction> buildMetricsRecorder(MethodHookConfiguration config) {
         Collection<MetricRecordingSettings> metricRecordingSettings = config.getMetrics();
         if (!metricRecordingSettings.isEmpty()) {
             List<MetricAccessor> metricAccessors = metricRecordingSettings.stream()
                     .map(this::buildMetricAccessor)
                     .collect(Collectors.toList());
-
             IHookAction recorder = new MetricsRecorder(metricAccessors, commonTagsManager, metricsManager, tagValueGuard);
 
             if (isTracingInternalActions() && config.isTraceExitHook()) {
@@ -238,6 +264,13 @@ private Optional<IHookAction> buildMetricsRecorder(MethodHookConfiguration confi
         }
     }
 
+    /**
+     * @return Returns whether metrics tags should be added to tracing as attributes
+     */
+    private boolean addMetricsToTracing() {
+        return environment.getCurrentConfig().getTracing().isAddMetricTags();
+    }
+
     /**
      * @return Returns whether action tracing should be enabled for internal actions (e.g. {@link MetricsRecorder}).
      */

diff --git a/...ks/inspectit/ocelot/core/instrumentation/hook/actions/span/WriteSpanAttributesAction.java b/...ks/inspectit/ocelot/core/instrumentation/hook/actions/span/WriteSpanAttributesAction.java
@@ -17,6 +17,7 @@
 public class WriteSpanAttributesAction implements IHookAction {
 
     @Singular
+    @Getter
     private final Map<String, VariableAccessor> attributeAccessors;
 
     private final Supplier<IObfuscatory> obfuscatorySupplier;