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