Profiling instrumentation source (#2186)

* Add the InstrumentationSource enum which will be used to differentiate between callstacks collected by the two profiling extensions present in the agent.

* Add an attribute specifying the instrumentation source of 'continuous' to profiling otel log messages.

* Include a lowercase name value on InstrumentationSource for use when exporting otel logs.

* Add missing test for including the frame count attribute in the profiling otel log message attributes.

* Configure the continuous CPU and Memory profiler log exporter with an InstrumentationSource of 'CONTINUOUS'.

* Apply spotless code formatting.

* Remove usage of List method 'getFirst' which is not available in JDK17.

* Add 'INSTRUMENTATION_SOURCE' constant in ProfilingSemanticAttributes.

* Add test asserting the expected number of attributes are included on every profilng log message.

* Use random log messages in PprofLogDataExporterTest.

Author: tduncan

profiler/src/main/java/com/splunk/opentelemetry/profiler/InstrumentationSource.java

@@ -0,0 +1,34 @@
+/*
+ * Copyright Splunk Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.splunk.opentelemetry.profiler;
+
+import java.util.Locale;
+
+public enum InstrumentationSource {
+  CONTINUOUS,
+  SNAPSHOT;
+
+  private final String value;
+
+  InstrumentationSource() {
+    this.value = name().toLowerCase(Locale.ROOT);
+  }
+
+  public String value() {
+    return value;
+  }
+}

profiler/src/main/java/com/splunk/opentelemetry/profiler/ProfilingSemanticAttributes.java

@@ -39,6 +39,8 @@ public class ProfilingSemanticAttributes {
   public static final AttributeKey<String> DATA_FORMAT = stringKey("profiling.data.format");
   public static final String PPROF_GZIP_BASE64 = "pprof-gzip-base64";
   public static final AttributeKey<Long> FRAME_COUNT = longKey("profiling.data.total.frame.count");
+  public static final AttributeKey<String> INSTRUMENTATION_SOURCE =
+      stringKey("profiling.instrumentation.source");
 
   public static final AttributeKey<Long> THREAD_ID = longKey("thread.id");
   public static final AttributeKey<String> THREAD_NAME = stringKey("thread.name");

profiler/src/main/java/com/splunk/opentelemetry/profiler/allocation/exporter/PprofAllocationEventExporter.java

@@ -29,6 +29,7 @@
 import com.google.perftools.profiles.ProfileProto.Profile;
 import com.google.perftools.profiles.ProfileProto.Sample;
 import com.splunk.opentelemetry.profiler.EventReader;
+import com.splunk.opentelemetry.profiler.InstrumentationSource;
 import com.splunk.opentelemetry.profiler.ProfilingDataType;
 import com.splunk.opentelemetry.profiler.allocation.sampler.AllocationEventSampler;
 import com.splunk.opentelemetry.profiler.exporter.PprofLogDataExporter;
@@ -51,7 +52,8 @@ private PprofAllocationEventExporter(Builder builder) {
     this.eventReader = builder.eventReader;
     this.stackDepth = builder.stackDepth;
     this.pprofLogDataExporter =
-        new PprofLogDataExporter(builder.otelLogger, ProfilingDataType.ALLOCATION);
+        new PprofLogDataExporter(
+            builder.otelLogger, ProfilingDataType.ALLOCATION, InstrumentationSource.CONTINUOUS);
   }
 
   @Override

profiler/src/main/java/com/splunk/opentelemetry/profiler/exporter/PprofCpuEventExporter.java

@@ -27,6 +27,7 @@
 import static com.splunk.opentelemetry.profiler.ProfilingSemanticAttributes.TRACE_ID;
 
 import com.google.perftools.profiles.ProfileProto.Sample;
+import com.splunk.opentelemetry.profiler.InstrumentationSource;
 import com.splunk.opentelemetry.profiler.ProfilingDataType;
 import com.splunk.opentelemetry.profiler.context.StackToSpanLinkage;
 import com.splunk.opentelemetry.profiler.events.EventPeriods;
@@ -46,7 +47,9 @@ public class PprofCpuEventExporter implements CpuEventExporter {
   private PprofCpuEventExporter(Builder builder) {
     this.eventPeriods = builder.eventPeriods;
     this.stackDepth = builder.stackDepth;
-    this.pprofLogDataExporter = new PprofLogDataExporter(builder.otelLogger, ProfilingDataType.CPU);
+    this.pprofLogDataExporter =
+        new PprofLogDataExporter(
+            builder.otelLogger, ProfilingDataType.CPU, InstrumentationSource.CONTINUOUS);
   }
 
   @Override

profiler/src/main/java/com/splunk/opentelemetry/profiler/exporter/PprofLogDataExporter.java

@@ -19,11 +19,13 @@
 import static com.splunk.opentelemetry.profiler.ProfilingSemanticAttributes.DATA_FORMAT;
 import static com.splunk.opentelemetry.profiler.ProfilingSemanticAttributes.DATA_TYPE;
 import static com.splunk.opentelemetry.profiler.ProfilingSemanticAttributes.FRAME_COUNT;
+import static com.splunk.opentelemetry.profiler.ProfilingSemanticAttributes.INSTRUMENTATION_SOURCE;
 import static com.splunk.opentelemetry.profiler.ProfilingSemanticAttributes.PPROF_GZIP_BASE64;
 import static com.splunk.opentelemetry.profiler.ProfilingSemanticAttributes.PROFILING_SOURCE;
 import static com.splunk.opentelemetry.profiler.ProfilingSemanticAttributes.SOURCE_TYPE;
 import static java.util.logging.Level.FINE;
 
+import com.splunk.opentelemetry.profiler.InstrumentationSource;
 import com.splunk.opentelemetry.profiler.ProfilingDataType;
 import io.opentelemetry.api.common.Attributes;
 import io.opentelemetry.api.logs.Logger;
@@ -37,14 +39,16 @@ public class PprofLogDataExporter {
   private final ProfilingDataType dataType;
   private final Attributes commonAttributes;
 
-  public PprofLogDataExporter(Logger otelLogger, ProfilingDataType dataType) {
+  public PprofLogDataExporter(
+      Logger otelLogger, ProfilingDataType dataType, InstrumentationSource instrumentationSource) {
     this.otelLogger = otelLogger;
     this.dataType = dataType;
     this.commonAttributes =
         Attributes.builder()
             .put(SOURCE_TYPE, PROFILING_SOURCE)
             .put(DATA_TYPE, dataType.value())
             .put(DATA_FORMAT, PPROF_GZIP_BASE64)
+            .put(INSTRUMENTATION_SOURCE, instrumentationSource.value())
             .build();
   }
 

profiler/src/test/java/com/splunk/opentelemetry/profiler/InstrumentationSourceTest.java

@@ -0,0 +1,32 @@
+/*
+ * Copyright Splunk Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.splunk.opentelemetry.profiler;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.util.Locale;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.EnumSource;
+
+class InstrumentationSourceTest {
+  @ParameterizedTest
+  @EnumSource(InstrumentationSource.class)
+  void valueIsLowerCaseOfEnumName(InstrumentationSource source) {
+    var value = source.value();
+    assertEquals(source.name().toLowerCase(Locale.ROOT), value);
+  }
+}

profiler/src/test/java/com/splunk/opentelemetry/profiler/exporter/InMemoryOtelLogger.java

@@ -0,0 +1,226 @@
+/*
+ * Copyright Splunk Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.splunk.opentelemetry.profiler.exporter;
+
+import io.opentelemetry.api.common.AttributeKey;
+import io.opentelemetry.api.common.Attributes;
+import io.opentelemetry.api.common.AttributesBuilder;
+import io.opentelemetry.api.logs.LogRecordBuilder;
+import io.opentelemetry.api.logs.Logger;
+import io.opentelemetry.api.logs.Severity;
+import io.opentelemetry.api.trace.Span;
+import io.opentelemetry.api.trace.SpanContext;
+import io.opentelemetry.context.Context;
+import io.opentelemetry.sdk.common.InstrumentationScopeInfo;
+import io.opentelemetry.sdk.logs.data.Body;
+import io.opentelemetry.sdk.logs.data.LogRecordData;
+import io.opentelemetry.sdk.resources.Resource;
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+import java.util.concurrent.TimeUnit;
+import org.junit.jupiter.api.extension.AfterEachCallback;
+import org.junit.jupiter.api.extension.ExtensionContext;
+
+/**
+ * In memory implementation of the OpenTelemetry {@link Logger} interface that allows for direct
+ * access to the collected logs. Intended for testing use only.
+ */
+class InMemoryOtelLogger implements Logger, AfterEachCallback {
+  private final List<LogRecordData> records = new ArrayList<>();
+
+  @Override
+  public LogRecordBuilder logRecordBuilder() {
+    return new Builder(this);
+  }
+
+  @Override
+  public void afterEach(ExtensionContext extensionContext) {
+    records.clear();
+  }
+
+  List<LogRecordData> records() {
+    return Collections.unmodifiableList(records);
+  }
+
+  static class Builder implements LogRecordBuilder {
+    private final InMemoryOtelLogger logger;
+    private long timestampEpochNanos;
+    private long observedTimestampEpochNanos;
+    private Context context = Context.current();
+    private Severity severity = Severity.UNDEFINED_SEVERITY_NUMBER;
+    private String severityText = "";
+    private String body = "";
+    private final AttributesBuilder attributes = Attributes.builder();
+
+    private Builder(InMemoryOtelLogger logger) {
+      this.logger = logger;
+    }
+
+    @Override
+    public LogRecordBuilder setTimestamp(Instant instant) {
+      return setTimestamp(instant.toEpochMilli(), TimeUnit.MILLISECONDS);
+    }
+
+    @Override
+    public LogRecordBuilder setTimestamp(long timestamp, TimeUnit unit) {
+      this.timestampEpochNanos = unit.toNanos(timestamp);
+      return this;
+    }
+
+    @Override
+    public LogRecordBuilder setObservedTimestamp(Instant instant) {
+      return setObservedTimestamp(instant.toEpochMilli(), TimeUnit.MILLISECONDS);
+    }
+
+    @Override
+    public LogRecordBuilder setObservedTimestamp(long timestamp, TimeUnit unit) {
+      this.observedTimestampEpochNanos = unit.toNanos(timestamp);
+      return this;
+    }
+
+    @Override
+    public LogRecordBuilder setContext(Context context) {
+      this.context = Objects.requireNonNull(context);
+      return this;
+    }
+
+    @Override
+    public LogRecordBuilder setSeverity(Severity severity) {
+      this.severity = Objects.requireNonNull(severity);
+      return this;
+    }
+
+    @Override
+    public LogRecordBuilder setSeverityText(String severityText) {
+      this.severityText = Objects.requireNonNull(severityText);
+      return this;
+    }
+
+    @Override
+    public LogRecordBuilder setBody(String body) {
+      this.body = Objects.requireNonNull(body);
+      return this;
+    }
+
+    @Override
+    public <T> LogRecordBuilder setAttribute(AttributeKey<T> key, T value) {
+      attributes.put(Objects.requireNonNull(key), Objects.requireNonNull(value));
+      return this;
+    }
+
+    @Override
+    public void emit() {
+      logger.records.add(
+          new LogRecord(
+              null,
+              null,
+              timestampEpochNanos,
+              observedTimestampEpochNanos,
+              Span.fromContext(context).getSpanContext(),
+              severity,
+              severityText,
+              Body.string(body),
+              attributes.build()));
+    }
+  }
+
+  static class LogRecord implements LogRecordData {
+    private final Resource resource;
+    private final InstrumentationScopeInfo instrumentationScopeInfo;
+    private final long timestampEpochNanos;
+    private final long observedTimestampEpochNanos;
+    private final SpanContext spanContext;
+    private final Severity severity;
+    private final String severityText;
+    private final Body body;
+    private final Attributes attributes;
+
+    LogRecord(
+        Resource resource,
+        InstrumentationScopeInfo instrumentationScopeInfo,
+        long timestampEpochNanos,
+        long observedTimestampEpochNanos,
+        SpanContext spanContext,
+        Severity severity,
+        String severityText,
+        Body body,
+        Attributes attributes) {
+      this.resource = resource;
+      this.instrumentationScopeInfo = instrumentationScopeInfo;
+      this.timestampEpochNanos = timestampEpochNanos;
+      this.observedTimestampEpochNanos = observedTimestampEpochNanos;
+      this.spanContext = spanContext;
+      this.severity = severity;
+      this.severityText = severityText;
+      this.body = body;
+      this.attributes = attributes;
+    }
+
+    @Override
+    public Resource getResource() {
+      return resource;
+    }
+
+    @Override
+    public InstrumentationScopeInfo getInstrumentationScopeInfo() {
+      return instrumentationScopeInfo;
+    }
+
+    @Override
+    public long getTimestampEpochNanos() {
+      return timestampEpochNanos;
+    }
+
+    @Override
+    public long getObservedTimestampEpochNanos() {
+      return observedTimestampEpochNanos;
+    }
+
+    @Override
+    public SpanContext getSpanContext() {
+      return spanContext;
+    }
+
+    @Override
+    public Severity getSeverity() {
+      return severity;
+    }
+
+    @Override
+    public String getSeverityText() {
+      return severityText;
+    }
+
+    @Override
+    public Body getBody() {
+      return body;
+    }
+
+    @Override
+    public Attributes getAttributes() {
+      return attributes;
+    }
+
+    @Override
+    public int getTotalAttributeCount() {
+      return attributes.size();
+    }
+  }
+}