Providing metrics from a microservice

  1// tag::copyright[]
  2/*******************************************************************************
  3 * Copyright (c) 2017, 2022 IBM Corporation and others.
  4 * All rights reserved. This program and the accompanying materials
  5 * are made available under the terms of the Eclipse Public License 2.0
  6 * which accompanies this distribution, and is available at
  7 * http://www.eclipse.org/legal/epl-2.0/
  8 *
  9 * SPDX-License-Identifier: EPL-2.0
 10 *******************************************************************************/
 11// end::copyright[]
 12// tag::MetricsTest[]
 13package it.io.openliberty.guides.metrics;
 14
 15import static org.junit.jupiter.api.Assertions.assertEquals;
 16import static org.junit.jupiter.api.Assertions.assertTrue;
 17import static org.junit.jupiter.api.Assertions.fail;
 18
 19import java.io.BufferedReader;
 20import java.io.FileInputStream;
 21import java.io.IOException;
 22import java.io.InputStream;
 23import java.io.InputStreamReader;
 24import java.security.KeyStore;
 25import java.util.ArrayList;
 26import java.util.HashMap;
 27import java.util.List;
 28import java.util.Map;
 29import java.util.Properties;
 30
 31import jakarta.ws.rs.client.Client;
 32import jakarta.ws.rs.client.ClientBuilder;
 33import jakarta.ws.rs.core.MediaType;
 34import jakarta.ws.rs.core.Response;
 35
 36import org.junit.jupiter.api.AfterEach;
 37import org.junit.jupiter.api.BeforeAll;
 38import org.junit.jupiter.api.BeforeEach;
 39import org.junit.jupiter.api.MethodOrderer.OrderAnnotation;
 40import org.junit.jupiter.api.Order;
 41import org.junit.jupiter.api.Test;
 42import org.junit.jupiter.api.TestMethodOrder;
 43
 44// tag::TestMethodOrder[]
 45@TestMethodOrder(OrderAnnotation.class)
 46// end::TestMethodOrder[]
 47public class MetricsIT {
 48
 49  private static final String KEYSTORE_PATH = System.getProperty("user.dir")
 50                              + "/target/liberty/wlp/usr/servers/"
 51                              + "defaultServer/resources/security/key.p12";
 52  private static final String SYSTEM_ENV_PATH =  System.getProperty("user.dir")
 53                              + "/target/liberty/wlp/usr/servers/"
 54                              + "defaultServer/server.env";
 55
 56  private static String httpPort;
 57  private static String httpsPort;
 58  private static String baseHttpUrl;
 59  private static String baseHttpsUrl;
 60  private static KeyStore keystore;
 61
 62  private List<String> metrics;
 63  private Client client;
 64
 65  private final String INVENTORY_HOSTS = "inventory/systems";
 66  private final String INVENTORY_HOSTNAME = "inventory/systems/localhost";
 67  private final String METRICS_APPLICATION = "metrics?scope=application";
 68
 69  // tag::BeforeAll[]
 70  @BeforeAll
 71  // end::BeforeAll[]
 72  // tag::oneTimeSetup[]
 73  public static void oneTimeSetup() throws Exception {
 74    httpPort = System.getProperty("http.port");
 75    httpsPort = System.getProperty("https.port");
 76    baseHttpUrl = "http://localhost:" + httpPort + "/";
 77    baseHttpsUrl = "https://localhost:" + httpsPort + "/";
 78    loadKeystore();
 79  }
 80  // end::oneTimeSetup[]
 81
 82  private static void loadKeystore() throws Exception {
 83    Properties sysEnv = new Properties();
 84    sysEnv.load(new FileInputStream(SYSTEM_ENV_PATH));
 85    char[] password = sysEnv.getProperty("keystore_password").toCharArray();
 86    keystore = KeyStore.getInstance("PKCS12");
 87    keystore.load(new FileInputStream(KEYSTORE_PATH), password);
 88  }
 89
 90  // tag::BeforeEach[]
 91  @BeforeEach
 92  // end::BeforeEach[]
 93  // tag::setup[]
 94  public void setup() {
 95    client = ClientBuilder.newBuilder().trustStore(keystore).build();
 96  }
 97  // end::setup[]
 98
 99  // tag::AfterEach[]
100  @AfterEach
101  // end::AfterEach[]
102  // tag::teardown[]
103  public void teardown() {
104    client.close();
105  }
106  // end::teardown[]
107
108  // tag::Test1[]
109  @Test
110  // end::Test1[]
111  // tag::Order1[]
112  @Order(1)
113  // end::Order1[]
114  // tag::testPropertiesRequestTimeMetric[]
115  public void testPropertiesRequestTimeMetric() {
116    connectToEndpoint(baseHttpUrl + INVENTORY_HOSTNAME);
117    metrics = getMetrics();
118    for (String metric : metrics) {
119      if (metric.startsWith(
120          "application_inventoryProcessingTime_rate_per_second")) {
121        float seconds = Float.parseFloat(metric.split(" ")[1]);
122        assertTrue(4 > seconds);
123      }
124    }
125  }
126  // end::testPropertiesRequestTimeMetric[]
127
128  // tag::Test2[]
129  @Test
130  // end::Test2[]
131  // tag::Order2[]
132  @Order(2)
133  // end::Order2[]
134  // tag::testInventoryAccessCountMetric[]
135  public void testInventoryAccessCountMetric() {
136    metrics = getMetrics();
137    Map<String, Integer> accessCountsBefore = getIntMetrics(metrics,
138            "application_inventoryAccessCount_total");
139    connectToEndpoint(baseHttpUrl + INVENTORY_HOSTS);
140    metrics = getMetrics();
141    Map<String, Integer> accessCountsAfter = getIntMetrics(metrics,
142            "application_inventoryAccessCount_total");
143    for (String key : accessCountsBefore.keySet()) {
144      Integer accessCountBefore = accessCountsBefore.get(key);
145      Integer accessCountAfter = accessCountsAfter.get(key);
146      assertTrue(accessCountAfter > accessCountBefore);
147    }
148  }
149  // end::testInventoryAccessCountMetric[]
150
151  // tag::Test3[]
152  @Test
153  // end::Test3[]
154  // tag::Order3[]
155  @Order(3)
156  // end::Order3[]
157  // tag::testInventorySizeGaugeMetric[]
158  public void testInventorySizeGaugeMetric() {
159    metrics = getMetrics();
160    Map<String, Integer> inventorySizeGauges = getIntMetrics(metrics,
161            "application_inventorySizeGauge");
162    for (Integer value : inventorySizeGauges.values()) {
163      assertTrue(1 <= value);
164    }
165  }
166  // end::testInventorySizeGaugeMetric[]
167
168  // tag::Test4[]
169  @Test
170  // end::Test4[]
171  // tag::Order4[]
172  @Order(4)
173  // end::Order4[]
174  // tag::testPropertiesAddTimeMetric[]
175  public void testPropertiesAddTimeMetric() {
176    connectToEndpoint(baseHttpUrl + INVENTORY_HOSTNAME);
177    metrics = getMetrics();
178    boolean checkMetric = false;
179    for (String metric : metrics) {
180      if (metric.startsWith(
181          "inventoryAddingTime_seconds_count")) {
182            checkMetric = true;
183      }
184    }
185    assertTrue(checkMetric);
186  }
187  // end::testPropertiesAddTimeMetric[]
188
189  public void connectToEndpoint(String url) {
190    Response response = this.getResponse(url);
191    this.assertResponse(url, response);
192    response.close();
193  }
194
195  private List<String> getMetrics() {
196    String usernameAndPassword = "admin" + ":" + "adminpwd";
197    String authorizationHeaderValue = "Basic "
198        + java.util.Base64.getEncoder()
199                          .encodeToString(usernameAndPassword.getBytes());
200    Response metricsResponse = client.target(baseHttpsUrl + METRICS_APPLICATION)
201                                     .request(MediaType.TEXT_PLAIN)
202                                     .header("Authorization",
203                                         authorizationHeaderValue)
204                                     .get();
205
206    BufferedReader br = new BufferedReader(new InputStreamReader((InputStream)
207    metricsResponse.getEntity()));
208    List<String> result = new ArrayList<String>();
209    try {
210      String input;
211      while ((input = br.readLine()) != null) {
212        result.add(input);
213      }
214      br.close();
215    } catch (IOException e) {
216      e.printStackTrace();
217      fail();
218    }
219
220    metricsResponse.close();
221    return result;
222  }
223
224  private Response getResponse(String url) {
225    return client.target(url).request().get();
226  }
227
228  private void assertResponse(String url, Response response) {
229    assertEquals(200, response.getStatus(), "Incorrect response code from " + url);
230  }
231
232  private Map<String, Integer> getIntMetrics(List<String> metrics, String metricName) {
233    Map<String, Integer> output = new HashMap<String, Integer>();
234    for (String metric : metrics) {
235      if (metric.startsWith(metricName)) {
236        String[] mSplit = metric.split(" ");
237        String key = mSplit[0];
238        Integer value = Integer.parseInt(mSplit[mSplit.length - 1]);
239        output.put(key, value);
240      }
241    }
242    return output;
243  }
244}
245// end::MetricsTest[]

  1// tag::copyright[]
  2/*******************************************************************************
  3 * Copyright (c) 2017, 2022 IBM Corporation and others.
  4 * All rights reserved. This program and the accompanying materials
  5 * are made available under the terms of the Eclipse Public License 2.0
  6 * which accompanies this distribution, and is available at
  7 * http://www.eclipse.org/legal/epl-2.0/
  8 *
  9 * SPDX-License-Identifier: EPL-2.0
 10 *******************************************************************************/
 11// end::copyright[]
 12// tag::InventoryManager[]
 13package io.openliberty.guides.inventory;
 14
 15import java.util.ArrayList;
 16import java.util.Collections;
 17import java.util.List;
 18import java.util.Properties;
 19
 20import jakarta.enterprise.context.ApplicationScoped;
 21
 22import org.eclipse.microprofile.metrics.MetricUnits;
 23import org.eclipse.microprofile.metrics.annotation.Counted;
 24import org.eclipse.microprofile.metrics.annotation.Gauge;
 25import org.eclipse.microprofile.metrics.annotation.Timed;
 26
 27import io.openliberty.guides.inventory.model.InventoryList;
 28import io.openliberty.guides.inventory.model.SystemData;
 29
 30// tag::ApplicationScoped[]
 31@ApplicationScoped
 32// end::ApplicationScoped[]
 33public class InventoryManager {
 34
 35  private List<SystemData> systems = Collections.synchronizedList(new ArrayList<>());
 36  private InventoryUtils invUtils = new InventoryUtils();
 37
 38  // tag::timedForGet[]
 39  // tag::nameForGet[]
 40  @Timed(name = "inventoryProcessingTime",
 41  // end::nameForGet[]
 42         // tag::tagForGet[]
 43         tags = {"method=get"},
 44         // end::tagForGet[]
 45         // tag::absoluteForGet[]
 46         absolute = true,
 47         // end::absoluteForGet[]
 48         // tag::desForGet[]
 49         description = "Time needed to process the inventory")
 50         // end::desForGet[]
 51  // end::timedForGet[]
 52  // tag::get[]
 53  public Properties get(String hostname) {
 54    return invUtils.getProperties(hostname);
 55  }
 56  // end::get[]
 57
 58  // tag::timedForAdd[]
 59  // tag::nameForAdd[]
 60  @Timed(name = "inventoryAddingTime",
 61  // end::nameForAdd[]
 62    // tag::absoluteForAdd[]
 63    absolute = true,
 64    // end::absoluteForAdd[]
 65    // tag::desForAdd[]
 66    description = "Time needed to add system properties to the inventory")
 67    // end::desForAdd[]
 68  // end::timedForAdd[]
 69  // tag::add[]
 70  public void add(String hostname, Properties systemProps) {
 71    Properties props = new Properties();
 72    props.setProperty("os.name", systemProps.getProperty("os.name"));
 73    props.setProperty("user.name", systemProps.getProperty("user.name"));
 74
 75    SystemData host = new SystemData(hostname, props);
 76    if (!systems.contains(host)) {
 77      systems.add(host);
 78    }
 79  }
 80  // end::add[]
 81
 82  // tag::timedForList[]
 83  // tag::nameForList[]
 84  @Timed(name = "inventoryProcessingTime",
 85  // end::nameForList[]
 86         // tag::tagForList[]
 87         tags = {"method=list"},
 88         // end::tagForList[]
 89         // tag::absoluteForList[]
 90         absolute = true,
 91         // end::absoluteForList[]
 92         // tag::desForList[]
 93         description = "Time needed to process the inventory")
 94         // end::desForList[]
 95  // end::timedForList[]
 96  // tag::countedForList[]
 97  @Counted(name = "inventoryAccessCount",
 98           absolute = true,
 99           description = "Number of times the list of systems method is requested")
100  // end::countedForList[]
101  // tag::list[]
102  public InventoryList list() {
103    return new InventoryList(systems);
104  }
105  // end::list[]
106
107  // tag::gaugeForGetTotal[]
108  // tag::unitForGetTotal[]
109  @Gauge(unit = MetricUnits.NONE,
110  // end::unitForGetTotal[]
111         name = "inventorySizeGauge",
112         absolute = true,
113         description = "Number of systems in the inventory")
114  // end::gaugeForGetTotal[]
115  // tag::getTotal[]
116  public int getTotal() {
117    return systems.size();
118  }
119  // end::getTotal[]
120}
121// end::InventoryManager[]