HeartBeat Feature Implementation

CHANGELOG.md

@@ -1,5 +1,8 @@
 # CHANGELOG
 
+# Version 2.1.0
+- Introduced Heartbeat support to monitor application health periodically.
+
 ## Version 2.0.2 
 - Fix incorrect success flag set when capturing HTTP Dependency.
 - Fix [#577](https://github.com/Microsoft/ApplicationInsights-Java/issues/577), removed HttpFactory class as it was not being used.

core/src/main/java/com/microsoft/applicationinsights/TelemetryConfiguration.java

@@ -188,4 +188,11 @@ public void setInstrumentationKey(String key) {
 
         instrumentationKey = key;
     }
+
+    /**
+     * Method for tear down in tests
+     */
+    private static void setActiveAsNull() {
+        active = null;
+    }
 }

core/src/main/java/com/microsoft/applicationinsights/internal/config/TelemetryConfigurationFactory.java

@@ -21,6 +21,7 @@
 
 package com.microsoft.applicationinsights.internal.config;
 
+import com.microsoft.applicationinsights.internal.heartbeat.HeartBeatModule;
 import java.io.InputStream;
 import java.util.Map;
 import java.util.List;
@@ -119,7 +120,9 @@ public final void initialize(TelemetryConfiguration configuration) {
     private void setMinimumConfiguration(ApplicationInsightsXmlConfiguration userConfiguration, TelemetryConfiguration configuration) {
         setInstrumentationKey(userConfiguration, configuration);
         configuration.setChannel(new InProcessTelemetryChannel());
+        addHeartBeatModule(configuration);
         setContextInitializers(null, configuration);
+        initializeComponents(configuration);
     }
 
     private void setInternalLogger(SDKLoggerXmlElement sdkLogger, TelemetryConfiguration configuration) {
@@ -173,7 +176,13 @@ private void setTelemetryModules(ApplicationInsightsXmlConfiguration appConfigur
             ReflectionUtils.loadComponents(TelemetryModule.class, modules, configurationModules.getAdds());
         }
 
+        //if heartbeat module is not loaded, load heartbeat module
+        if (!isHeartBeatModuleAdded(modules)) {
+            addHeartBeatModule(configuration);
+        }
+
         List<TelemetryModule> pcModules = getPerformanceModules(appConfiguration.getPerformance());
+
         modules.addAll(pcModules);
     }
 
@@ -502,6 +511,27 @@ private void initializeComponents(TelemetryConfiguration configuration) {
         }
     }
 
+    /**
+     * Adds heartbeat module with default configuration
+     * @param configuration TelemetryConfiguration Instance
+     */
+    private void addHeartBeatModule(TelemetryConfiguration configuration) {
+        HeartBeatModule module = new HeartBeatModule(new HashMap<String, String>());
+        configuration.getTelemetryModules().add(module);
+    }
+
+    /**
+     * Checks if heartbeat module is present
+     * @param module List of modules in current TelemetryConfiguration Instance
+     * @return true if heartbeat module is present
+     */
+    private boolean isHeartBeatModuleAdded(List<TelemetryModule> module) {
+        for (TelemetryModule mod : module) {
+            if (mod instanceof HeartBeatModule) return true;
+        }
+        return false;
+    }
+
     void setPerformanceCountersSection(String performanceCountersSection) {
         this.performanceCountersSection = performanceCountersSection;
     }

core/src/main/java/com/microsoft/applicationinsights/internal/heartbeat/BaseDefaultHeartbeatPropertyProvider.java

@@ -0,0 +1,162 @@
+package com.microsoft.applicationinsights.internal.heartbeat;
+
+import com.microsoft.applicationinsights.internal.logger.InternalLogger;
+import com.microsoft.applicationinsights.internal.util.PropertyHelper;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Properties;
+import java.util.Set;
+import java.util.UUID;
+import java.util.concurrent.Callable;
+import org.apache.commons.lang3.exception.ExceptionUtils;
+
+/**
+ * <h1>Base Heartbeat Property Provider</h1>
+ *
+ * <p>
+ *   This class is a concrete implementation of {@link com.microsoft.applicationinsights.internal.heartbeat.HeartBeatDefaultPayloadProviderInterface}
+ *   It enables setting SDK Metadata to heartbeat payload.
+ * </p>
+ *
+ * @author Dhaval Doshi
+ * @since 03-30-2018
+ */
+public class BaseDefaultHeartbeatPropertyProvider implements HeartBeatDefaultPayloadProviderInterface {
+
+  /**
+   * Collection holding default properties for this default provider.
+   */
+  private final Set<String> defaultFields;
+
+  /**
+   * Random GUID that would help in analysis when app has stopped and restarted. Each restart will
+   * have a new GUID. If the application is unstable and goes through frequent restarts this will help
+   * us identify instability in the analytics backend.
+   */
+  private static UUID uniqueProcessId;
+
+  /**
+   * Name of this provider.
+   */
+  private final String name = "Base";
+
+  public BaseDefaultHeartbeatPropertyProvider() {
+    defaultFields = new HashSet<>();
+    initializeDefaultFields(defaultFields);
+  }
+
+  @Override
+  public String getName() {
+    return this.name;
+  }
+
+  @Override
+  public boolean isKeyWord(String keyword) {
+    return defaultFields.contains(keyword);
+  }
+
+  @Override
+  public Callable<Boolean> setDefaultPayload(final List<String> disableFields,
+      final HeartBeatProviderInterface provider) {
+    return new Callable<Boolean>() {
+
+      // using volatile here to avoid caching in threads.
+      volatile boolean hasSetValues = false;
+      volatile Set<String> enabledProperties = MiscUtils.except(defaultFields, disableFields);
+      @Override
+      public Boolean call() {
+        for (String fieldName : enabledProperties) {
+          try {
+            switch (fieldName) {
+              case "jdkVersion":
+                provider.addHeartBeatProperty(fieldName, getJdkVersion(), true);
+                hasSetValues = true;
+                break;
+              case "sdk-version":
+                provider.addHeartBeatProperty(fieldName, getSdkVersion(), true);
+                hasSetValues = true;
+                break;
+              case "osType":
+                provider.addHeartBeatProperty(fieldName, getOsType(), true);
+                hasSetValues = true;
+                break;
+              case "processSessionId":
+                provider.addHeartBeatProperty(fieldName, getProcessSessionId(), true);
+                hasSetValues = true;
+                break;
+              default:
+                //We won't accept unknown properties in default providers.
+                InternalLogger.INSTANCE.trace("Encountered unknown default property");
+                break;
+            }
+          }
+          catch (Exception e) {
+           InternalLogger.INSTANCE.warn("Failed to obtain heartbeat property, stack trace"
+               + "is: %s", ExceptionUtils.getStackTrace(e));
+          }
+        }
+        return hasSetValues;
+      }
+    };
+  }
+
+  /**
+   * This method initializes the collection with Default Properties of this provider.
+   * @param defaultFields collection to hold default properties.
+   */
+  private void initializeDefaultFields(Set<String> defaultFields) {
+
+    if (defaultFields == null) {
+      defaultFields = new HashSet<>();
+    }
+    defaultFields.add("jdkVersion");
+    defaultFields.add("sdk-version");
+    defaultFields.add("osType");
+    defaultFields.add("processSessionId");
+  }
+
+  /**
+   * Gets the JDK version being used by the application
+   * @return String representing JDK Version
+   */
+  private String getJdkVersion() {
+    return System.getProperty("java.version");
+  }
+
+  /**
+   * Returns the Application Insights SDK version user is using to instrument his application
+   * @return returns string prefixed with "java" representing the Application Insights Java
+   * SDK version.
+   */
+  private String getSdkVersion() {
+
+    String sdkVersion = "java";
+
+    Properties sdkVersionProps = PropertyHelper.getSdkVersionProperties();
+    if (sdkVersionProps != null) {
+      String version = sdkVersionProps.getProperty("version");
+      sdkVersion = String.format("java:%s", version);
+      return sdkVersion;
+    }
+    return sdkVersion + ":unknown-version";
+  }
+
+  /**
+   * Gets the OS version on which application is running.
+   * @return String representing OS version
+   */
+  private String getOsType() {
+    return System.getProperty("os.name");
+  }
+
+  /**
+   * Returns the Unique GUID for the application's current session.
+   * @return String representing GUID for each running session
+   */
+  private String getProcessSessionId() {
+    if (uniqueProcessId == null) {
+      uniqueProcessId = UUID.randomUUID();
+    }
+    return uniqueProcessId.toString();
+  }
+}

core/src/main/java/com/microsoft/applicationinsights/internal/heartbeat/HeartBeatDefaultPayloadProviderInterface.java

@@ -0,0 +1,43 @@
+package com.microsoft.applicationinsights.internal.heartbeat;
+
+import java.util.List;
+import java.util.concurrent.Callable;
+
+/**
+ * <h1>Interface for setting default properties</h1>
+ *
+ * <p>
+ *   This interface is used to set the default payload of a provider and defines implementation for
+ *   some helper methods to assist it.
+ *
+ *   The default concrete implementations are {@link com.microsoft.applicationinsights.internal.heartbeat.BaseDefaultHeartbeatPropertyProvider}
+ *   and {@link com.microsoft.applicationinsights.internal.heartbeat.WebAppsDefaultHeartbeatProvider}
+ * </p>
+ *
+ * @author Dhaval Doshi
+ * @since 03-30-2018
+ */
+public interface HeartBeatDefaultPayloadProviderInterface {
+
+  /**
+   * Returns the name of the heartbeat provider.
+   * @return Name of the heartbeat provider
+   */
+  String getName();
+
+  /**
+   * Tells if the input string is a reserved property.
+   * @param keyword string to test
+   * @return true if input string is reserved keyword
+   */
+  boolean isKeyWord(String keyword);
+
+  /**
+   * Returns a callable which can be executed to set the payload based on the parameters.
+   * @param disableFields List of Properties to be excluded from payload
+   * @param provider The current heartbeat provider
+   * @return Callable which can be executed to add the payload
+   */
+  Callable<Boolean> setDefaultPayload(List<String> disableFields, HeartBeatProviderInterface provider);
+
+}