/** * Registers the given alert. If the passed {@link Alert} does not refer to the business * transaction metric, then the registration fails. * * @param alert * the {@link Alert} to register */ public void registerAlert(Alert alert) { if (alert == null) { throw new IllegalArgumentException("The given alert may not be null."); } else if (alert.getId() == null) { throw new IllegalArgumentException("The alert must have an ID."); } else if (alert.getAlertingDefinition() == null) { throw new IllegalArgumentException("The alert must have an alerting definition."); } registry.put(alert.getId(), alert); }
/** * Returns string representation of an alert. * * @param alert * {@link Alert} instance to create string for. * @return Returns string representation of an alert. */ public static String getAlertDescription(Alert alert) { String closing = alert.isOpen() ? "Open" : DateFormat.getDateTimeInstance().format(new Date(alert.getStopTimestamp())); return alert.getAlertingDefinition().getName() + " (" + DateFormat.getDateTimeInstance().format(new Date(alert.getStartTimestamp())) + " - " + closing + ")"; }
/** * Returns all business transaction alerts in the registry. * * @return Returns all business transaction alerts in the registry. */ public List<Alert> getBusinessTransactionAlerts() { List<Alert> resultList = new ArrayList<>(); for (Alert alert : getAlerts()) { if (AlertingUtils.isBusinessTransactionAlert(alert.getAlertingDefinition())) { resultList.add(alert); } } return resultList; } }
/** * Creates a influxDB query for the given alert id. The query retrieves the ids of the * invocation sequences that constitute the alert. * * @param alert * the alert to retrieve the invocation IDs for. * @return Returns the query string. */ public static String buildTraceIdForAlertQuery(Alert alert) { StringBuilder builder = new StringBuilder(); builder.append("SELECT \"").append(Series.BusinessTransaction.FIELD_TRACE_ID).append("\" FROM \"").append(Series.BusinessTransaction.NAME); builder.append("\" WHERE time >= ").append(alert.getStartTimestamp()).append("ms"); if (alert.getStopTimestamp() >= 0) { builder.append(" AND time < ").append(alert.getStopTimestamp()).append("ms"); } for (Entry<String, String> entry : alert.getAlertingDefinition().getTags().entrySet()) { builder.append(" AND \"").append(entry.getKey()).append("\" = '").append(entry.getValue()).append('\''); } builder.append(" AND \"").append(Series.BusinessTransaction.FIELD_DURATION).append("\" >= ").append(alert.getAlertingDefinition().getThreshold()); return builder.toString(); } }
@Test public void registerSuccessful() { Alert testAlert = Mockito.mock(Alert.class, Mockito.RETURNS_MOCKS); when(testAlert.getId()).thenReturn("id"); alertRegistry.registerAlert(testAlert); verify(testAlert, times(2)).getId(); verify(testAlert).getAlertingDefinition(); verifyNoMoreInteractions(testAlert); assertThat(alertRegistry.getAlert("id"), equalTo(testAlert)); }
@Test public void testConstruction2() { Alert alert = new Alert(alertingDefinition, 1L, 2L); assertThat(alert.getId(), notNullValue()); assertThat(alert.getAlertingDefinition(), is(alertingDefinition)); assertThat(alert.getStartTimestamp(), is(1L)); assertThat(alert.getStopTimestamp(), is(2L)); } }
@Test public void testConstruction1() { Alert alert = new Alert(alertingDefinition, 1L); assertThat(alert.getId(), notNullValue()); assertThat(alert.getAlertingDefinition(), is(alertingDefinition)); assertThat(alert.getStartTimestamp(), is(1L)); }
@Test public void getAlert() { Alert testAlert = Mockito.mock(Alert.class, Mockito.RETURNS_MOCKS); when(testAlert.getId()).thenReturn("id"); alertRegistry.registerAlert(testAlert); Alert alert = alertRegistry.getAlert("id"); verify(testAlert, times(2)).getId(); verify(testAlert).getAlertingDefinition(); verifyNoMoreInteractions(testAlert); assertThat(alert, equalTo(testAlert)); }
@Test public void replaceAlert() throws Exception { Alert alertOne = Mockito.mock(Alert.class, Mockito.RETURNS_MOCKS); when(alertOne.getId()).thenReturn("id"); Alert alertTwo = Mockito.mock(Alert.class, Mockito.RETURNS_MOCKS); when(alertTwo.getId()).thenReturn("id"); alertRegistry.registerAlert(alertOne); alertRegistry.registerAlert(alertTwo); verify(alertOne, times(2)).getId(); verify(alertOne).getAlertingDefinition(); verify(alertTwo, times(2)).getId(); verify(alertTwo).getAlertingDefinition(); verifyNoMoreInteractions(alertOne, alertTwo); assertThat(alertRegistry.getAlert("id"), equalTo(alertTwo)); } }
@Test public void getAlerts() { Alert alertOne = Mockito.mock(Alert.class, Mockito.RETURNS_MOCKS); Alert alertTwo = Mockito.mock(Alert.class, Mockito.RETURNS_MOCKS); when(alertOne.getId()).thenReturn("id_1"); when(alertTwo.getId()).thenReturn("id_2"); alertRegistry.registerAlert(alertOne); alertRegistry.registerAlert(alertTwo); List<Alert> alerts = alertRegistry.getAlerts(); verify(alertOne, times(2)).getId(); verify(alertOne).getAlertingDefinition(); verify(alertTwo, times(2)).getId(); verify(alertTwo).getAlertingDefinition(); verifyNoMoreInteractions(alertOne, alertTwo); assertThat(alerts, hasSize(2)); assertThat(alerts, hasItems(alertOne, alertTwo)); } }
@Test public void getOnlyBTAlerts() { AlertingDefinition definitionOne = Mockito.mock(AlertingDefinition.class); AlertingDefinition definitionTwo = Mockito.mock(AlertingDefinition.class); when(definitionOne.getMeasurement()).thenReturn(Series.BusinessTransaction.NAME); when(definitionOne.getField()).thenReturn(Series.BusinessTransaction.FIELD_DURATION); Alert alertOne = Mockito.mock(Alert.class); Alert alertTwo = Mockito.mock(Alert.class); when(alertOne.getId()).thenReturn("id_1"); when(alertTwo.getId()).thenReturn("id_2"); when(alertOne.getAlertingDefinition()).thenReturn(definitionOne); when(alertTwo.getAlertingDefinition()).thenReturn(definitionTwo); alertRegistry.registerAlert(alertOne); alertRegistry.registerAlert(alertTwo); verify(alertOne, times(2)).getId(); verify(alertOne).getAlertingDefinition(); verify(alertTwo, times(2)).getId(); verify(alertTwo).getAlertingDefinition(); verifyNoMoreInteractions(alertOne, alertTwo); List<Alert> alerts = alertRegistry.getBusinessTransactionAlerts(); assertThat(alerts, hasSize(1)); assertThat(alerts, hasItems(alertOne)); } }
@Test @SuppressWarnings("unchecked") public void startAlert() { IAlertAction alertAction = Mockito.mock(IAlertAction.class); Iterator<IAlertAction> iterator = Mockito.mock(Iterator.class); when(iterator.hasNext()).thenReturn(true, false); when(iterator.next()).thenReturn(alertAction); when(alertActions.iterator()).thenReturn(iterator); AlertingState alertingState = Mockito.mock(AlertingState.class); AlertingDefinition alertingDefinition = Mockito.mock(AlertingDefinition.class); when(alertingState.getAlertingDefinition()).thenReturn(alertingDefinition); when(alertingState.getLastCheckTime()).thenReturn(1234L); alertingService.alertStarting(alertingState, 1.0D); ArgumentCaptor<Alert> captor = ArgumentCaptor.forClass(Alert.class); verify(alertRegistry).registerAlert(captor.capture()); verifyNoMoreInteractions(alertRegistry); assertThat(captor.getValue().getAlertingDefinition(), is(alertingDefinition)); assertThat(captor.getValue().getStartTimestamp(), is(1234L)); verify(alertAction).onStarting(alertingState); verify(alertActions).iterator(); verifyNoMoreInteractions(alertActions); verify(alertingState).getAlertingDefinition(); verify(alertingState).getLastCheckTime(); verify(alertingState).setAlert(any(Alert.class)); verify(alertingState).setExtremeValue(1.0D); verifyNoMoreInteractions(alertingState); }
throw new BusinessException("Retrieving invocation sequences for alert with id '" + alertId + "'", AlertErrorCodeEnum.UNKNOWN_ALERT_ID); if (!AlertingUtils.isBusinessTransactionAlert(alert.getAlertingDefinition())) { throw new BusinessException("The given alert '" + alertId + "' is not related to a buisness transaction.", AlertErrorCodeEnum.NO_BTX_ALERT);