Added resources as runtimeOnly dependency

.gitignore

@@ -1,3 +1,4 @@
 .gradle/
 build/
 .env
+.idea/

build.gradle

@@ -40,6 +40,7 @@ dependencies {
     implementation "io.opentelemetry:opentelemetry-exporter-otlp-logs:$otelVersion-alpha"
     implementation "io.opentelemetry:opentelemetry-exporter-logging" // only for debug
     runtimeOnly("io.opentelemetry.instrumentation:opentelemetry-logback-appender-1.0:$otelVersion-alpha")
+    runtimeOnly "io.opentelemetry.instrumentation:opentelemetry-resources:$otelVersion-alpha"
     implementation "io.opentelemetry.instrumentation:opentelemetry-micrometer-1.5:$otelVersion-alpha"
     implementation "io.opentelemetry:opentelemetry-sdk-extension-autoconfigure:$otelVersion-alpha"
     runtimeOnly 'io.micrometer:micrometer-tracing-bridge-otel'

src/main/java/com/grafana/opentelemetry/GrafanaProperties.java

@@ -17,25 +17,38 @@ public class GrafanaProperties {
      * <p>
      * For example, you can add <code>service.version</code> to make it easier to see if a new version of the
      * application is causing a problem.
+     *
      * <p>
      * The attributes <code>service.name</code>, <code>service.version</code>, and <code>service.instance.id</code>
-     * are automatically detected as explained below, but if you set the value manually, it will be respected.
+     * are automatically detected as outlined below.
+     *
      * <p>
-     * "spring.application.name" in application.properties will be translated to <code>service.name</code>.
-     * <p>
-     * You can also add the application name and version to MANIFEST.MF, where they will be copied to
-     * <code>service.name</code> and <code>service.version</code> respectively.
-     * <p>
-     * In gradle, the application name and version can be set as follows:
+     * For <code>service.name</code> the order of precedence is:
+     *     <ol>
+     *       <li>environment variable OTEL_SERVICE_NAME</li>
+     *       <li>Manually set service_name in grafana.otlp.globalAttributes</li>
+     *       <li>spring.application.name" in application.properties</li>
+     *       <li>'Implementation-Title' in jar's MANIFEST.MF</li>
+     *     </ol>
+     *
+     *<p>
+     * The following block can be added to build.gradle to set the application name and version
+     * in the jar's MANIFEST.MF:
      * <pre>
      * bootJar {
      *     manifest {
      *         attributes('Implementation-Title':   'Demo Application',
-     *                    'Implementation-Version': version)
+     *                    'Implementation-Version':  version)
      *     }
      * }
      * </pre>
-     * The environment variables HOST or HOSTNAME will be translated to <code>service.instance.id</code>.
+     * The <code>service.instance.id</code> attribute will be set if any of the following return a value.
+     * The list is in order of precedence.
+     *   <ol>
+     *    <li>InetAddress.getLocalHost().getHostName()</li>
+     *    <li>environment variable HOSTNAME</li>
+     *    <li>environment variable HOST</li>
+     *   </ol>
      */
     private final Map<String, String> globalAttributes = new HashMap<>();
 

src/main/java/com/grafana/opentelemetry/OpenTelemetryConfig.java

@@ -16,6 +16,8 @@
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 
+import java.net.InetAddress;
+import java.net.UnknownHostException;
 import java.util.Base64;
 import java.util.HashMap;
 import java.util.Map;
@@ -117,12 +119,12 @@ static Optional<String> getEndpoint(String endpoint, String zone, Optional<Strin
             }
         } else {
             if (hasZone) {
-                logger.warn("ignoring grafana.otlp.cloud.zone, because grafana.otlp.onprem.endpoint was found");
+                logger.warn("ignoring grafana.otlp.cloud.zone, because grafana.otlp.cloud.instanceId was not found");
             }
             if (hasEndpoint) {
                 return Optional.of(endpoint);
             } else {
-                logger.warn("please specify grafana.otlp.onprem.endpoint");
+                logger.info("grafana.otlp.onprem.endpoint not found, using default endpoint for otel.exporter.otlp.protocol");
             }
         }
         return Optional.empty();
@@ -169,11 +171,17 @@ private static String getResourceAttributes(GrafanaProperties properties, String
             // ignore error reading manifest
         }
 
-        updateResourceAttribute(resourceAttributes, ResourceAttributes.SERVICE_NAME, applicationName,
-                manifestApplicationName);
+        updateResourceAttribute(resourceAttributes, ResourceAttributes.SERVICE_NAME, applicationName, manifestApplicationName);
         updateResourceAttribute(resourceAttributes, ResourceAttributes.SERVICE_VERSION, manifestApplicationVersion);
-        updateResourceAttribute(resourceAttributes, ResourceAttributes.SERVICE_INSTANCE_ID, System.getenv("HOSTNAME"),
-                System.getenv("HOST"));
+
+        String hostName;
+        try {
+            hostName = InetAddress.getLocalHost().getHostName();
+        } catch (UnknownHostException e) {
+            hostName = System.getenv("HOSTNAME");
+        }
+        updateResourceAttribute(resourceAttributes, ResourceAttributes.SERVICE_INSTANCE_ID,
+                hostName, System.getenv("HOST"));
 
         return resourceAttributes.entrySet().stream()
                        .map(e -> String.format("%s=%s", e.getKey(), e.getValue()))

src/test/java/com/grafana/opentelemetry/OpenTelemetryConfigTest.java

@@ -74,8 +74,13 @@ private static Stream<Arguments> basicAuthCases() {
 
     @ParameterizedTest(name = "{0}")
     @MethodSource("endpointCases")
-    void getEndpoint(String name, Optional<String> expected, String expectedOutput,
-            String zone, String endpoint, Optional<String> authHeader, CapturedOutput output) {
+    void getEndpoint(String name,
+                     Optional<String> expected,
+                     String expectedOutput,
+                     String zone,
+                     String endpoint,
+                     Optional<String> authHeader,
+                     CapturedOutput output) {
         Assertions.assertThat(OpenTelemetryConfig.getEndpoint(endpoint, zone, authHeader)).isEqualTo(expected);
         Assertions.assertThat(output).contains(expectedOutput);
     }
@@ -85,24 +90,24 @@ private static Stream<Arguments> endpointCases() {
                 Arguments.of("only zone",
                         Optional.of("https://otlp-gateway-zone.grafana.net/otlp"), "",
                         "zone", "", Optional.of("apiKey")),
-                Arguments.of("only endpoint",
+                Arguments.of("only onprem endpoint",
                         Optional.of("endpoint"), "",
                         "", "endpoint", Optional.empty()),
                 Arguments.of("both with cloud",
                         Optional.of("https://otlp-gateway-zone.grafana.net/otlp"),
                         "ignoring grafana.otlp.onprem.endpoint, because grafana.otlp.cloud.instanceId was found",
                         "zone", "endpoint", Optional.of("key")),
-                Arguments.of("both without cloud",
+                Arguments.of("zone without instanceId",
                         Optional.of("endpoint"),
-                        "ignoring grafana.otlp.cloud.zone, because grafana.otlp.onprem.endpoint was found",
+                        "ignoring grafana.otlp.cloud.zone, because grafana.otlp.cloud.instanceId was not found",
                         "zone", "endpoint", Optional.empty()),
                 Arguments.of("missing zone",
                         Optional.empty(),
                         "please specify grafana.otlp.cloud.zone",
                         " ", " ", Optional.of("key")),
-                Arguments.of("missing endpoint",
+                Arguments.of("onprem endpoint not set",
                         Optional.empty(),
-                        "please specify grafana.otlp.onprem.endpoint",
+                        "grafana.otlp.onprem.endpoint not found, using default endpoint for otel.exporter.otlp.protocol",
                         " ", " ", Optional.empty())
         );
     }