Merge pull request #2471 from newrelic/Sampling-Target

Updates to support sampling_target.

Author: jbedell-newrelic

newrelic-agent/src/main/java/com/newrelic/agent/RPMService.java

@@ -47,6 +47,7 @@
 import com.newrelic.agent.transport.HttpError;
 import com.newrelic.agent.transport.HttpResponseCode;
 import com.newrelic.agent.utilization.UtilizationData;
+import com.newrelic.api.agent.NewRelic;
 import org.json.simple.JSONStreamAware;
 
 import java.lang.management.ManagementFactory;
@@ -237,6 +238,9 @@ private Map<String, Object> getSettings(boolean sendEnvironmentInfo) {
         }
         settings.put("services", ServiceFactory.getServicesConfiguration());
 
+        // the sysprops and envvars above an in unmodifiable collections, so just change it here
+        updateSamplingTargetSettings(settings);
+
         return settings;
     }
 
@@ -969,6 +973,58 @@ private void handle503Error(Exception e) {
         }
     }
 
+    private void updateSamplingTargetSettings (Map<String, Object> settings) {
+        // the new distributed_tracing.sampler.adaptive_sampling_target is meant to be per minute
+        // but, the harvest cycle is 12 times per minute right now,
+        // so we need to divide this number by 12 until that changes
+        // there are 2 spots we need to do this:
+        //   - settings.distributed_tracing_sampler_adaptive_sampling_target
+        //   - settings.distributed_tracing.sampler.adaptive_sampling_target
+        if (settings == null) return;
+        try {
+            // local settings
+            Map<String, Object> dtConfig = (Map<String, Object>) settings.get("distributed_tracing");
+            if (dtConfig != null) {
+                Map<String, Object> samplerConfig = (Map<String, Object>) dtConfig.get("sampler");
+                if (samplerConfig != null) {
+                    Integer adaptiveSamplingTarget = toInt(samplerConfig.get("adaptive_sampling_target"));
+                    if (adaptiveSamplingTarget != null) {
+                        Integer newAdaptiveSamplingTarget = (int) Math.ceil(adaptiveSamplingTarget.doubleValue() / 12.0);
+                        NewRelic.getAgent()
+                                .getLogger()
+                                .log(Level.FINE, "Updating local setting adaptive_sampling_target from " + adaptiveSamplingTarget + " to " +
+                                        newAdaptiveSamplingTarget);
+                        samplerConfig.put("adaptive_sampling_target", newAdaptiveSamplingTarget);
+                    }
+                }
+            }
+        } catch (Exception e) {
+            NewRelic.getAgent().getLogger().log(Level.WARNING, "Unable to parse local setting adaptive_sampling_target setting: {0}", e);
+        }
+
+        try {
+            // env var
+            if (settings.containsKey("distributed_tracing_sampler_adaptive_sampling_target")) {
+                Integer adaptiveSamplingTarget = toInt(settings.get("distributed_tracing_sampler_adaptive_sampling_target"));
+                Integer newAdaptiveSamplingTarget = (int) Math.ceil(adaptiveSamplingTarget.doubleValue() / 12.0);
+                NewRelic.getAgent()
+                        .getLogger()
+                        .log(Level.FINE, "Updating environment variable adaptive_sampling_target from " + adaptiveSamplingTarget + " to " +
+                                newAdaptiveSamplingTarget);
+                settings.put("distributed_tracing_sampler_adaptive_sampling_target", newAdaptiveSamplingTarget);
+            }
+        } catch (Exception e) {
+            NewRelic.getAgent().getLogger().log(Level.WARNING, "Unable to parse environment variable adaptive_sampling_target setting: {0}", e);
+        }
+    }
+
+    private static Integer toInt(Object o) {
+        if (o instanceof Number) {
+            return ((Number) o).intValue();
+        }
+        return ((Double)Double.parseDouble((String)o)).intValue();
+    }
+
     @Override
     protected void doStop() {
         removeHarvestablesFromServices(appName);

newrelic-agent/src/main/java/com/newrelic/agent/config/DistributedTracingConfig.java

@@ -7,11 +7,15 @@
 
 package com.newrelic.agent.config;
 
+import com.newrelic.api.agent.NewRelic;
+
 import java.util.Map;
+import java.util.logging.Level;
 
 public class DistributedTracingConfig extends BaseConfig {
 
     private static final boolean DEFAULT_DISTRIBUTED_TRACING = true;
+    private static final Integer DEFAULT_ADAPTIVE_SAMPLING_TARGET = 120;
     private static final String SYSTEM_PROPERTY_ROOT = "newrelic.config.distributed_tracing.";
 
     public static final String ENABLED = "enabled";
@@ -26,7 +30,13 @@ public class DistributedTracingConfig extends BaseConfig {
     public static final String REMOTE_PARENT_NOT_SAMPLED = "remote_parent_not_sampled";
     public static final String SAMPLE_ALWAYS_ON = "always_on";
     public static final String SAMPLE_ALWAYS_OFF = "always_off";
-    public static final String SAMPLE_DEFAULT = "default";
+
+    // note: there is no special logic for these yet, as they are just the fallback if the other values don't exist
+    // if we have to add special logic, we should treat one as an alias of the other
+    public static final String SAMPLE_DEFAULT = "default"; // same as 'adaptive_sampling'
+    public static final String SAMPLE_ADAPTIVE_SAMPLING = "adaptive_sampling"; // same as 'default'
+
+    public static final String ADAPTIVE_SAMPLING_TARGET = "adaptive_sampling_target";  // see below
 
     private final boolean enabled;
     private final String trustedAccountKey;
@@ -36,6 +46,11 @@ public class DistributedTracingConfig extends BaseConfig {
     private final String remoteParentSampled;
     private final String remoteParentNotSampled;
 
+    // will be passed up on connect and come back down as just 'sampling_target'
+    // which will get assigned to transaction_events.target_samples_stored
+    // so, even though it's not directly used in code here, it is necessary
+    private final Integer adaptiveSamplingTarget;
+
     DistributedTracingConfig(Map<String, Object> props) {
         super(props, SYSTEM_PROPERTY_ROOT);
         this.enabled = getProperty(ENABLED, DEFAULT_DISTRIBUTED_TRACING);
@@ -45,6 +60,7 @@ public class DistributedTracingConfig extends BaseConfig {
         this.includeNewRelicHeader = !getProperty(EXCLUDE_NEWRELIC_HEADER, false);
 
         BaseConfig samplerConfig = new BaseConfig(nestedProps(SAMPLER), SYSTEM_PROPERTY_ROOT+SAMPLER+".");
+        this.adaptiveSamplingTarget = samplerConfig.getProperty(ADAPTIVE_SAMPLING_TARGET, DEFAULT_ADAPTIVE_SAMPLING_TARGET);
         this.remoteParentSampled = samplerConfig.getProperty(REMOTE_PARENT_SAMPLED, SAMPLE_DEFAULT);
         this.remoteParentNotSampled = samplerConfig.getProperty(REMOTE_PARENT_NOT_SAMPLED, SAMPLE_DEFAULT);
     }