[health] bootstrap HealthObserver from agent to API

logstash-core/lib/logstash/agent.rb

@@ -40,6 +40,8 @@ class LogStash::Agent
  attr_reader :metric, :name, :settings, :dispatcher, :ephemeral_id, :pipeline_bus
  attr_accessor :logger
 
+ attr_reader :health_observer
+
  # initialize method for LogStash::Agent
  # @param params [Hash] potential parameters are:
  # :name [String] - identifier for the agent
@@ -51,6 +53,9 @@ def initialize(settings = LogStash::SETTINGS, source_loader = nil)
  @auto_reload = setting("config.reload.automatic")
  @ephemeral_id = SecureRandom.uuid
 
+ java_import("org.logstash.health.HealthObserver")
+ @health_observer = HealthObserver.new
+
  # Mutex to synchronize in the exclusive method
  # Initial usage for the Ruby pipeline initialization which is not thread safe
  @webserver_control_lock = Mutex.new

logstash-core/lib/logstash/api/commands/default_metadata.rb

@@ -28,7 +28,7 @@ def all
  :id => service.agent.id,
  :name => service.agent.name,
  :ephemeral_id => service.agent.ephemeral_id,
- :status => "green", # This is hard-coded to mirror x-pack behavior
+ :status => service.agent.health_observer.status,
  :snapshot => ::BUILD_INFO["build_snapshot"],
  :pipeline => {
  :workers => LogStash::SETTINGS.get("pipeline.workers"),

logstash-core/src/main/java/org/logstash/health/HealthObserver.java

@@ -0,0 +1,21 @@
+package org.logstash.health;
+
+import com.google.common.collect.Iterables;
+
+import java.util.EnumSet;
+
+public class HealthObserver {
+ public final Status getStatus() {
+ // INTERNAL-ONLY Proof-of-concept to show flow-through to API results
+ switch (System.getProperty("logstash.apiStatus", "green")) {
+ case "green": return Status.GREEN;
+ case "yellow": return Status.YELLOW;
+ case "red": return Status.RED;
+ case "random":
+ final EnumSet<Status> statuses = EnumSet.allOf(Status.class);
+ return Iterables.get(statuses, new java.util.Random().nextInt(statuses.size()));
+ default:
+ return Status.UNKNOWN;
+ }
+ }
+}

logstash-core/src/main/java/org/logstash/health/Status.java

@@ -0,0 +1,32 @@
+package org.logstash.health;
+
+import com.fasterxml.jackson.annotation.JsonValue;
+
+public enum Status {
+ UNKNOWN,
+ GREEN,
+ YELLOW,
+ RED,
+ ;
+
+ private final String externalValue = name().toLowerCase();
+
+ @JsonValue
+ public String externalValue() {
+ return externalValue;
+ }
+
+ /**
+ * Combine this status with another status.
+ * This method is commutative.
+ * @param status the other status
+ * @return the more-degraded of the two statuses.
+ */
+ public Status reduce(Status status) {
+ if (compareTo(status) >= 0) {
+ return this;
+ } else {
+ return status;
+ }
+ }
+}

logstash-core/src/test/java/org/logstash/health/StatusTest.java

@@ -0,0 +1,106 @@
+package org.logstash.health;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.junit.Test;
+import org.junit.experimental.runners.Enclosed;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.EnumSet;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import static com.google.common.collect.Collections2.orderedPermutations;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.logstash.health.Status.*;
+
+@RunWith(Enclosed.class)
+public class StatusTest {
+
+ public static class Tests {
+ @Test
+ public void testReduceUnknown() {
+ assertThat(UNKNOWN.reduce(UNKNOWN), is(UNKNOWN));
+ assertThat(UNKNOWN.reduce(GREEN), is(GREEN));
+ assertThat(UNKNOWN.reduce(YELLOW), is(YELLOW));
+ assertThat(UNKNOWN.reduce(RED), is(RED));
+ }
+
+ @Test
+ public void testReduceGreen() {
+ assertThat(GREEN.reduce(UNKNOWN), is(GREEN));
+ assertThat(GREEN.reduce(GREEN), is(GREEN));
+ assertThat(GREEN.reduce(YELLOW), is(YELLOW));
+ assertThat(GREEN.reduce(RED), is(RED));
+ }
+
+ @Test
+ public void testReduceYellow() {
+ assertThat(YELLOW.reduce(UNKNOWN), is(YELLOW));
+ assertThat(YELLOW.reduce(GREEN), is(YELLOW));
+ assertThat(YELLOW.reduce(YELLOW), is(YELLOW));
+ assertThat(YELLOW.reduce(RED), is(RED));
+ }
+
+ @Test
+ public void testReduceRed() {
+ assertThat(RED.reduce(UNKNOWN), is(RED));
+ assertThat(RED.reduce(GREEN), is(RED));
+ assertThat(RED.reduce(YELLOW), is(RED));
+ assertThat(RED.reduce(RED), is(RED));
+ }
+ }
+
+ @RunWith(Parameterized.class)
+ public static class JacksonSerialization {
+ @Parameters(name = "{0}")
+ public static Iterable<?> data() {
+ return EnumSet.allOf(Status.class);
+ }
+
+ @Parameter
+ public Status status;
+
+ private final ObjectMapper mapper = new ObjectMapper();
+
+ @Test
+ public void testSerialization() throws Exception {
+ assertThat(mapper.writeValueAsString(status), is(equalTo('"' + status.name().toLowerCase() + '"')));
+ }
+ }
+
+ @RunWith(Parameterized.class)
+ public static class ReduceCommutativeSpecification {
+ @Parameters(name = "{0}<=>{1}")
+ public static Collection<Object[]> data() {
+ return getCombinations(EnumSet.allOf(Status.class), 2);
+ }
+
+ @Parameter(0)
+ public Status statusA;
+ @Parameter(1)
+ public Status statusB;
+
+ @Test
+ public void testReduceCommutative() {
+ assertThat(statusA.reduce(statusB), is(statusB.reduce(statusA)));
+ }
+
+ private static <T extends Comparable<T>> List<Object[]> getCombinations(Collection<T> source, int count) {
+ return orderedPermutations(source).stream()
+ .map((l) -> l.subList(0, count))
+ .map(ArrayList::new).peek(Collections::sort)
+ .collect(Collectors.toSet())
+ .stream()
+ .map(List::toArray)
+ .collect(Collectors.toList());
+ }
+ }
+}