org.eclipse.microprofile.metrics.annotation.Metered Java Examples

@Timed(name = "websocket_onOpen_timer",
    reusable = true,
    tags = "label=websocket")
@Counted(name = "websocket_onOpen_count",
    monotonic = true,
    reusable = true,
    tags = "label=websocket")
@Metered(name = "websocket_onOpen_meter",
    reusable = true,
    tags = "label=websocket")
@OnOpen
public void onOpen(Session session, EndpointConfig ec) {
    Log.log(Level.FINE, this, "A new connection has been made to the room.");

    // All we have to do in onOpen is send the acknowledgement
    sendMessage(session, Message.ACK_MSG);
}
 

/**
 * Simple broadcast: loop over all mentioned sessions to send the message
 * <p>
 * We are effectively always broadcasting: a player could be connected
 * to more than one device, and that could correspond to more than one connected
 * session. Allow topic filtering on the receiving side (Mediator and browser)
 * to filter out and display messages.
 *
 * @param session Target session (used to find all related sessions)
 * @param message Message to send
 * @see #sendRemoteTextMessage(Session, Message)
 */
@Timed(name = "websocket_sendMessage_timer",
    reusable = true,
    tags = "label=websocket")
@Counted(name = "websocket_sendMessage_count",
    monotonic = true,
    reusable = true,
    tags = "label=websocket")
@Metered(name = "websocket_sendMessage_meter",
    reusable = true,
    tags = "label=websocket")
public void sendMessage(Session session, Message message) {
    for (Session s : session.getOpenSessions()) {
        sendMessageToSession(s, message);
    }
}
 

@Override
public String name() {
    if (annotation instanceof Counted) {
        return ((Counted) annotation).name();
    } else if (annotation instanceof ConcurrentGauge) {
        return ((ConcurrentGauge) annotation).name();
    } else if (annotation instanceof Gauge) {
        return ((Gauge) annotation).name();
    } else if (annotation instanceof Metered) {
        return ((Metered) annotation).name();
    } else if (annotation instanceof Timed) {
        return ((Timed) annotation).name();
    } else if (annotation instanceof SimplyTimed) {
        return ((SimplyTimed) annotation).name();
    } else {
        throw new IllegalArgumentException("Unknown metric annotation type " + annotation.annotationType());
    }
}
 

@Override
public boolean absolute() {
    if (annotation instanceof Counted) {
        return ((Counted) annotation).absolute();
    } else if (annotation instanceof ConcurrentGauge) {
        return ((ConcurrentGauge) annotation).absolute();
    } else if (annotation instanceof Gauge) {
        return ((Gauge) annotation).absolute();
    } else if (annotation instanceof Metered) {
        return ((Metered) annotation).absolute();
    } else if (annotation instanceof Timed) {
        return ((Timed) annotation).absolute();
    } else if (annotation instanceof SimplyTimed) {
        return ((SimplyTimed) annotation).absolute();
    } else {
        throw SmallRyeMetricsMessages.msg.unknownMetricAnnotationType(annotation.annotationType());
    }
}
 

@Override
public String[] tags() {
    if (annotation instanceof Counted) {
        return ((Counted) annotation).tags();
    } else if (annotation instanceof ConcurrentGauge) {
        return ((ConcurrentGauge) annotation).tags();
    } else if (annotation instanceof Gauge) {
        return ((Gauge) annotation).tags();
    } else if (annotation instanceof Metered) {
        return ((Metered) annotation).tags();
    } else if (annotation instanceof Timed) {
        return ((Timed) annotation).tags();
    } else if (annotation instanceof SimplyTimed) {
        return ((SimplyTimed) annotation).tags();
    } else {
        throw SmallRyeMetricsMessages.msg.unknownMetricAnnotationType(annotation.annotationType());
    }
}
 

@Override
public String unit() {
    if (annotation instanceof Counted) {
        return ((Counted) annotation).unit();
    } else if (annotation instanceof ConcurrentGauge) {
        return ((ConcurrentGauge) annotation).unit();
    } else if (annotation instanceof Gauge) {
        return ((Gauge) annotation).unit();
    } else if (annotation instanceof Metered) {
        return ((Metered) annotation).unit();
    } else if (annotation instanceof Timed) {
        return ((Timed) annotation).unit();
    } else if (annotation instanceof SimplyTimed) {
        return ((SimplyTimed) annotation).unit();
    } else {
        throw SmallRyeMetricsMessages.msg.unknownMetricAnnotationType(annotation.annotationType());
    }
}
 

@Override
public String description() {
    if (annotation instanceof Counted) {
        return ((Counted) annotation).description();
    } else if (annotation instanceof ConcurrentGauge) {
        return ((ConcurrentGauge) annotation).description();
    } else if (annotation instanceof Gauge) {
        return ((Gauge) annotation).description();
    } else if (annotation instanceof Metered) {
        return ((Metered) annotation).description();
    } else if (annotation instanceof Timed) {
        return ((Timed) annotation).description();
    } else if (annotation instanceof SimplyTimed) {
        return ((SimplyTimed) annotation).description();
    } else {
        throw SmallRyeMetricsMessages.msg.unknownMetricAnnotationType(annotation.annotationType());
    }
}
 

@Override
public String displayName() {
    if (annotation instanceof Counted) {
        return ((Counted) annotation).displayName();
    } else if (annotation instanceof ConcurrentGauge) {
        return ((ConcurrentGauge) annotation).displayName();
    } else if (annotation instanceof Gauge) {
        return ((Gauge) annotation).displayName();
    } else if (annotation instanceof Metered) {
        return ((Metered) annotation).displayName();
    } else if (annotation instanceof Timed) {
        return ((Timed) annotation).displayName();
    } else if (annotation instanceof SimplyTimed) {
        return ((SimplyTimed) annotation).displayName();
    } else {
        throw SmallRyeMetricsMessages.msg.unknownMetricAnnotationType(annotation.annotationType());
    }
}
 

@Timed(name = "websocket_onError_timer",
    reusable = true,
    tags = "label=websocket")
@Counted(name = "websocket_onError_count",
    monotonic = true,
    reusable = true,
    tags = "label=websocket")
@Metered(name = "websocket_onError_meter",
    reusable = true,
    tags = "label=websocket")
@OnError
public void onError(Session session, Throwable t) {
    Log.log(Level.FINE, this, "A problem occurred on connection", t);

    // TODO: Careful with what might revealed about implementation details!!
    // We're opting for making debug easy..
    tryToClose(session,
            new CloseReason(CloseReason.CloseCodes.UNEXPECTED_CONDITION,
                    trimReason(t.getClass().getName())));
}
 

@Path("/week/status")
@Metered(name = "weeklyStatus", unit = MetricUnits.MINUTES, description = "Metrics to weekly weather status method", absolute = true)
@GET
@Produces(MediaType.TEXT_PLAIN)
public String weekStatus() {
    return "Hi, week will be mostly sunny!";
}
 

@GET
@Counted(name="aCounter", monotonic = true, absolute = true)
@Metered(name="aMeter", absolute = true)
@Timed(  name="aTimer", absolute = true)
public String triggerAllMetrics() {

  justACounter.inc(2);

  return "Yo!";

}
 

@Timed(name = "websocket_onClose_timer",
    reusable = true,
    tags = "label=websocket")
@Counted(name = "websocket_onClose_count",
    monotonic = true,
    reusable = true,
    tags = "label=websocket")
@Metered(name = "websocket_onClose_meter",
    reusable = true,
    tags = "label=websocket")
@OnClose
public void onClose(Session session, CloseReason r) {
    Log.log(Level.FINE, this, "A connection to the room has been closed with reason " + r);
}
 

@Counted(name = "counter")
@Gauge(name = "gauge", unit = MetricUnits.NONE)
@Metered(name = "meter")
@Timed(name = "timer")
public Long metricsMethod() {
    return 1234L;
}
 

@Metered(name = "getResourceMetered")
@Path("/metered")
@GET
@Produces(MediaType.APPLICATION_JSON)
public JsonObject getResourceMetered() {
    String response = getResource();

    return JSON.createObjectBuilder()
            .add("message", response)
            .build();
}
 

@GET
@Metered
@Produces(MediaType.APPLICATION_JSON)
public Response getQuoteOfTheDay() {

  JsonObject quoteOfTheDay = quotesClient.getQuoteOfTheDay();
  JsonPointer quotePointer = Json.createPointer("/contents/quotes/0/quote");
  JsonObject result = Json.createObjectBuilder()
    .add("quoteOfTheDay", quotePointer.getValue(quoteOfTheDay)).build();

  return Response.ok(result).build();
}
 

/**
 * The hook into the interesting room stuff.
 * @param session
 * @param message
 * @throws IOException
 */
@Timed(name = "websocket_onMessage_timer",
    reusable = true,
    tags = "label=websocket")
@Counted(name = "websocket_onMessage_count",
    monotonic = true,
    reusable = true,
    tags = "label=websocket")
@Metered(name = "websocket_onMessage_meter",
    reusable = true,
    tags = "label=websocket")
@OnMessage
public void receiveMessage(Session session, Message message) throws IOException {
    roomImplementation.handleMessage(session, message, this);
}
 

private <X> void findAnnotatedInterfaces(@Observes @WithAnnotations({ Counted.class, Gauge.class, Metered.class,
        SimplyTimed.class, Timed.class, ConcurrentGauge.class }) ProcessAnnotatedType<X> pat) {
    Class<X> clazz = pat.getAnnotatedType().getJavaClass();
    Package pack = clazz.getPackage();
    if (pack != null && pack.getName().equals(GaugeRegistrationInterceptor.class.getPackage().getName())) {
        return;
    }
    if (clazz.isInterface()) {
        // All declared metrics of an annotated interface are registered during AfterDeploymentValidation
        metricsInterfaces.add(clazz);
    }
}
 

@Path("/day/status")

    @Metered(name = "dailyStatus", unit = MetricUnits.MINUTES, description = "Metrics to daily weather status method", absolute = true)
    @GET
    @Produces(MediaType.TEXT_PLAIN)
    public String dayStatus() {
        return "Hi, today is a sunny day!";
    }
 

@Metered(name = "create-books",
        unit = MetricUnits.MILLISECONDS,
        description = "Monitor the rate events occured",
        absolute = true)
@POST
public Response create(Book book) {
    bookService.create(book);
    return Response.ok().build();
}
 

@Metered
public void defaultNameMeteredMethod() {
}
 

@OnMessage
@Metered(name = "rate_of_websocket_calls",
         displayName = "Rate of GameRound Websocket Calls",
         description = "Rate of incoming messages to the game round websocket",
         absolute = true)
public void onMessage(@PathParam("roundId") final String roundId, String message, Session session) {
    try {
        final InboundMessage msg = jsonb.fromJson(message, InboundMessage.class);
        final GameRound round = gameSvc.getRound(roundId);
        if (round == null || round.getGameState() == State.FINISHED) {
            log(roundId, "[onMessage] Received message for round that did not exist or has completed.  Closing this websocket connection.");
            if (round == null)
                closeWithError(session, roundId, "Round " + roundId + " did not exist.");
            // don't boot out players that may keep sending messages a few seconds after the game is done
            else if (!round.isPlayer(session))
                closeWithError(session, roundId, "Round " + roundId + " has already completed.");
            return;
        }
        //log(roundId, "[onMessage] msg=" + message);

        if (GameEvent.GAME_START == msg.event) {
            round.startGame();
        } else if (msg.direction != null) {
            boolean updated = round.updatePlayerDirection(session, msg);
            if (!updated)
                closeWithError(session, roundId, "Unable to update direction because client was not joined to round");
        } else if (msg.playerJoinedId != null && !msg.playerJoinedId.isEmpty()) {
            // Call playerserver for player in DB
            org.libertybikes.restclient.Player playerResponse = getPlayer(msg.playerJoinedId);
            if (playerResponse == null)
                closeWithError(session, roundId, "Unable to add player " + msg.playerJoinedId +
                                                 " to game. This is probably because the player has not been registered yet");
            else if (!round.addPlayer(session, msg.playerJoinedId, playerResponse.name, msg.hasGameBoard == null ? true : msg.hasGameBoard))
                closeWithError(session, roundId, "Unable to add player " + playerResponse.name
                                                 + " to game. This is probably because someone else with the same id is already in the game.");
        } else if (Boolean.TRUE == msg.isSpectator) {
            round.addSpectator(session);
        } else {
            closeWithError(session, roundId, jsonb.toJson(msg));
        }
    } catch (Exception e) {
        log(roundId, "ERR: " + e.getMessage());
        e.printStackTrace();
    }
}
 

@Metered(name = "meteredMethod", tags= {"number=two"})
public void meteredMethodTwo() {
}
 

@Metered(name = "meteredMethod", tags= {"number=one"})
public void meteredMethodOne() {
}
 

@Metered(name = "meteredMethod")
public void meteredMethod() {
}
 

@Metered(name = "meteredConstructor", absolute = true)
public MeteredConstructorBean() {
}
 

@Counted(name = "counter")
@Metered(name = "meter")
@Timed(name = "timer")
public MultipleMetricsConstructorBean() {
}
 

@Metered(absolute = true)
public void absoluteDefaultNameMeteredMethod() {
}
 

@Metered(name = "meteredMethod")
public void meteredMethod() {
}
 

@GET
@Path("/meter")
@Metered(name = "meter")
public String meter() {
    return "OK";
}
 

public Of<Metered> metered(BeanInfo topClass, MemberInfo element) {
    return resolverOf(topClass, element, Metered.class);
}