wip

Signed-off-by: Attila Mészáros <a_meszaros@apple.com>

Author: csviri

docs/content/en/docs/migration/v5-3-migration.md

@@ -28,19 +28,24 @@ to
 </dependency>
 ```
 
-
 ## Metrics interface changes
 
 The [Metrics](https://github.com/operator-framework/java-operator-sdk/blob/main/operator-framework-core/src/main/java/io/javaoperatorsdk/operator/api/monitoring/Metrics.java) 
 interface changed in non backwards compatible way, in order to make the API cleaner:
 
-The following table show the relevant changes:
+The following table shows the relevant method renames:
 
-1. `reconcileCustomResource` -> `submittedForReconciliation`
-2. `reconciliationExecutionStarted` -> `reconciliationStarted` 
-3. `reconciliationExecutionFinished` -> `successfulReconciliation`
-4. `cleanupDoneFor` -> `cleanupDone`
+| v5.2 method                        | v5.3 method                  |
+|------------------------------------|------------------------------|
+| `reconcileCustomResource`          | `reconciliationSubmitted`    |
+| `reconciliationExecutionStarted`   | `reconciliationStarted`      |
+| `reconciliationExecutionFinished`  | `reconciliationSucceeded`    |
+| `failedReconciliation`             | `reconciliationFailed`       |
+| `finishedReconciliation`           | `reconciliationFinished`     |
+| `cleanupDoneFor`                   | `cleanupDone`                |
+| `receivedEvent`                    | `eventReceived`              |
+| `timeControllerExecution`          | `timedControllerExecution`   |
 
 Other changes:
-
-- `finishedReconciliation(..)` method was extended with `RetryInfo`
+- `reconciliationFinished(..)` method is extended with `RetryInfo`
+- `monitorSizeOf(..)` method is removed.

micrometer-support/src/main/java/io/javaoperatorsdk/operator/monitoring/micrometer/MicrometerMetrics.java

@@ -146,7 +146,7 @@ public void controllerRegistered(Controller<? extends HasMetadata> controller) {
   }
 
   @Override
-  public <T> T timeControllerExecution(ControllerExecution<T> execution) {
+  public <T> T timedControllerExecution(ControllerExecution<T> execution) {
     final var name = execution.controllerName();
     final var execName = PREFIX + CONTROLLERS_EXECUTION + execution.name();
     final var resourceID = execution.resourceID();
@@ -183,7 +183,7 @@ public <T> T timeControllerExecution(ControllerExecution<T> execution) {
   }
 
   @Override
-  public void receivedEvent(Event event, Map<String, Object> metadata) {
+  public void eventReceived(Event event, Map<String, Object> metadata) {
     if (event instanceof ResourceEvent) {
       incrementCounter(
           event.getRelatedCustomResourceID(),
@@ -209,7 +209,7 @@ public void cleanupDone(ResourceID resourceID, Map<String, Object> metadata) {
   }
 
   @Override
-  public void submittedForReconciliation(
+  public void reconciliationSubmitted(
       HasMetadata resource, RetryInfo retryInfoNullable, Map<String, Object> metadata) {
     Optional<RetryInfo> retryInfo = Optional.ofNullable(retryInfoNullable);
     incrementCounter(
@@ -229,7 +229,7 @@ public void submittedForReconciliation(
   }
 
   @Override
-  public void successfulReconciliation(HasMetadata resource, Map<String, Object> metadata) {
+  public void reconciliationSucceeded(HasMetadata resource, Map<String, Object> metadata) {
     incrementCounter(ResourceID.fromResource(resource), RECONCILIATIONS_SUCCESS, metadata);
   }
 
@@ -253,7 +253,7 @@ public void reconciliationFinished(
   }
 
   @Override
-  public void failedReconciliation(
+  public void reconciliationFailed(
       HasMetadata resource, RetryInfo retry, Exception exception, Map<String, Object> metadata) {
     var cause = exception.getCause();
     if (cause == null) {

micrometer-support/src/main/java/io/javaoperatorsdk/operator/monitoring/micrometer/MicrometerMetricsV2.java

@@ -156,7 +156,7 @@ private String numberOfResourcesRefName(String name) {
   }
 
   @Override
-  public <T> T timeControllerExecution(ControllerExecution<T> execution) {
+  public <T> T timedControllerExecution(ControllerExecution<T> execution) {
     final var name = execution.controllerName();
     final var timer = executionTimers.get(name);
     return timer.record(
@@ -170,7 +170,7 @@ public <T> T timeControllerExecution(ControllerExecution<T> execution) {
   }
 
   @Override
-  public void receivedEvent(Event event, Map<String, Object> metadata) {
+  public void eventReceived(Event event, Map<String, Object> metadata) {
     if (event instanceof ResourceEvent resourceEvent) {
       if (resourceEvent.getAction() == ResourceAction.ADDED) {
         gauges.get(numberOfResourcesRefName(getControllerName(metadata))).incrementAndGet();
@@ -199,7 +199,7 @@ public void cleanupDone(ResourceID resourceID, Map<String, Object> metadata) {
   }
 
   @Override
-  public void submittedForReconciliation(
+  public void reconciliationSubmitted(
       HasMetadata resource, RetryInfo retryInfoNullable, Map<String, Object> metadata) {
     Optional<RetryInfo> retryInfo = Optional.ofNullable(retryInfoNullable);
 
@@ -217,7 +217,7 @@ public void submittedForReconciliation(
   }
 
   @Override
-  public void successfulReconciliation(HasMetadata resource, Map<String, Object> metadata) {
+  public void reconciliationSucceeded(HasMetadata resource, Map<String, Object> metadata) {
     incrementCounter(RECONCILIATIONS_SUCCESS, resource.getMetadata().getNamespace(), metadata);
   }
 
@@ -241,7 +241,7 @@ public void reconciliationFinished(
   }
 
   @Override
-  public void failedReconciliation(
+  public void reconciliationFailed(
       HasMetadata resource, RetryInfo retry, Exception exception, Map<String, Object> metadata) {
     incrementCounter(RECONCILIATIONS_FAILED, resource.getMetadata().getNamespace(), metadata);
   }

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/api/monitoring/AggregatedMetrics.java

@@ -34,7 +34,7 @@
  * All method calls are delegated to each metrics instance in the list in the order they were
  * provided to the constructor.
  *
- * <p><strong>Important:</strong> The {@link #timeControllerExecution(ControllerExecution)} method
+ * <p><strong>Important:</strong> The {@link #timedControllerExecution(ControllerExecution)} method
  * is handled specially - it is only invoked on the first metrics instance in the list, since it's
  * not an idempotent operation and can only be executed once. The controller execution cannot be
  * repeated multiple times as it would produce side effects and potentially inconsistent results.
@@ -71,22 +71,21 @@ public void controllerRegistered(Controller<? extends HasMetadata> controller) {
   }
 
   @Override
-  public void receivedEvent(Event event, Map<String, Object> metadata) {
-    metricsList.forEach(metrics -> metrics.receivedEvent(event, metadata));
+  public void eventReceived(Event event, Map<String, Object> metadata) {
+    metricsList.forEach(metrics -> metrics.eventReceived(event, metadata));
   }
 
   @Override
-  public void submittedForReconciliation(
+  public void reconciliationSubmitted(
       HasMetadata resource, RetryInfo retryInfo, Map<String, Object> metadata) {
-    metricsList.forEach(
-        metrics -> metrics.submittedForReconciliation(resource, retryInfo, metadata));
+    metricsList.forEach(metrics -> metrics.reconciliationSubmitted(resource, retryInfo, metadata));
   }
 
   @Override
-  public void failedReconciliation(
+  public void reconciliationFailed(
       HasMetadata resource, RetryInfo retry, Exception exception, Map<String, Object> metadata) {
     metricsList.forEach(
-        metrics -> metrics.failedReconciliation(resource, retry, exception, metadata));
+        metrics -> metrics.reconciliationFailed(resource, retry, exception, metadata));
   }
 
   @Override
@@ -106,12 +105,12 @@ public void cleanupDone(ResourceID resourceID, Map<String, Object> metadata) {
   }
 
   @Override
-  public void successfulReconciliation(HasMetadata resource, Map<String, Object> metadata) {
-    metricsList.forEach(metrics -> metrics.successfulReconciliation(resource, metadata));
+  public void reconciliationSucceeded(HasMetadata resource, Map<String, Object> metadata) {
+    metricsList.forEach(metrics -> metrics.reconciliationSucceeded(resource, metadata));
   }
 
   @Override
-  public <T> T timeControllerExecution(ControllerExecution<T> execution) throws Exception {
-    return metricsList.get(0).timeControllerExecution(execution);
+  public <T> T timedControllerExecution(ControllerExecution<T> execution) throws Exception {
+    return metricsList.get(0).timedControllerExecution(execution);
   }
 }

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/api/monitoring/Metrics.java

@@ -48,7 +48,7 @@ default void controllerRegistered(Controller<? extends HasMetadata> controller)
    * @param event the event
    * @param metadata metadata associated with the resource being processed
    */
-  default void receivedEvent(Event event, Map<String, Object> metadata) {}
+  default void eventReceived(Event event, Map<String, Object> metadata) {}
 
   /**
    * Called right before a resource is submitted to the ExecutorService for reconciliation.
@@ -57,7 +57,7 @@ default void receivedEvent(Event event, Map<String, Object> metadata) {}
    * @param retryInfo the current retry state information for the reconciliation request
    * @param metadata metadata associated with the resource being processed
    */
-  default void submittedForReconciliation(
+  default void reconciliationSubmitted(
       HasMetadata resource, RetryInfo retryInfo, Map<String, Object> metadata) {}
 
   default void reconciliationStarted(HasMetadata resource, Map<String, Object> metadata) {}
@@ -71,7 +71,7 @@ default void reconciliationStarted(HasMetadata resource, Map<String, Object> met
    * @param exception the exception that caused the failed reconciliation resulting in a retry
    * @param metadata metadata associated with the resource being processed
    */
-  default void failedReconciliation(
+  default void reconciliationFailed(
       HasMetadata resource,
       RetryInfo retryInfo,
       Exception exception,
@@ -86,7 +86,7 @@ default void failedReconciliation(
    * @param resource the {@link ResourceID} associated with the resource being processed
    * @param metadata metadata associated with the resource being processed
    */
-  default void successfulReconciliation(HasMetadata resource, Map<String, Object> metadata) {}
+  default void reconciliationSucceeded(HasMetadata resource, Map<String, Object> metadata) {}
 
   /**
    * Always called when the reconciliation is finished, not only if reconciliation successfully
@@ -115,7 +115,7 @@ default void cleanupDone(ResourceID resourceID, Map<String, Object> metadata) {}
    * {@link io.javaoperatorsdk.operator.api.reconciler.Cleaner#cleanup(HasMetadata, Context)}. Note
    * that instances are automatically created for you by the SDK and passed to your Metrics
    * implementation at the appropriate time to the {@link
-   * #timeControllerExecution(ControllerExecution)} method.
+   * #timedControllerExecution(ControllerExecution)} method.
    *
    * @param <T> the outcome type associated with the controller execution. Currently, one of {@link
    *     io.javaoperatorsdk.operator.api.reconciler.UpdateControl} or {@link
@@ -184,7 +184,7 @@ interface ControllerExecution<T> {
    * @throws Exception if an error occurred during the controller's execution, usually this should
    *     just be a pass-through of whatever the controller returned
    */
-  default <T> T timeControllerExecution(ControllerExecution<T> execution) throws Exception {
+  default <T> T timedControllerExecution(ControllerExecution<T> execution) throws Exception {
     return execution.execute();
   }
 }

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/processing/Controller.java

@@ -143,7 +143,7 @@ public Controller(
 
   @Override
   public UpdateControl<P> reconcile(P resource, Context<P> context) throws Exception {
-    return metrics.timeControllerExecution(
+    return metrics.timedControllerExecution(
         new ControllerExecution<>() {
           @Override
           public String name() {
@@ -196,7 +196,7 @@ public UpdateControl<P> execute() throws Exception {
   @Override
   public DeleteControl cleanup(P resource, Context<P> context) {
     try {
-      return metrics.timeControllerExecution(
+      return metrics.timedControllerExecution(
           new ControllerExecution<>() {
             @Override
             public String name() {

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/processing/event/EventProcessor.java

@@ -127,7 +127,7 @@ public synchronized void handleEvent(Event event) {
       var state = optionalState.orElseThrow();
       final var resourceID = event.getRelatedCustomResourceID();
       MDCUtils.addResourceIDInfo(resourceID);
-      metrics.receivedEvent(event, metricsMetadata);
+      metrics.eventReceived(event, metricsMetadata);
       handleEventMarking(event, state);
       if (!this.running) {
         if (state.deleteEventPresent()) {
@@ -180,7 +180,7 @@ private void submitReconciliationExecution(ResourceState state) {
                 state.deleteEventPresent(),
                 state.isDeleteFinalStateUnknown());
         state.unMarkEventReceived(triggerOnAllEvents());
-        metrics.submittedForReconciliation(latest, state.getRetry(), metricsMetadata);
+        metrics.reconciliationSubmitted(latest, state.getRetry(), metricsMetadata);
         log.debug("Executing events for custom resource. Scope: {}", executionScope);
         executor.execute(new ReconcilerExecutor(resourceID, executionScope));
       } else {
@@ -286,7 +286,7 @@ synchronized void eventProcessingFinished(
       return;
     }
     cleanupOnSuccessfulExecution(executionScope);
-    metrics.successfulReconciliation(executionScope.getResource(), metricsMetadata);
+    metrics.reconciliationSucceeded(executionScope.getResource(), metricsMetadata);
     if ((triggerOnAllEvents() && executionScope.isDeleteEvent())
         || (!triggerOnAllEvents() && state.deleteEventPresent())) {
       cleanupForDeletedEvent(executionScope.getResourceID());
@@ -362,7 +362,7 @@ private void handleRetryOnException(ExecutionScope<P> executionScope, Exception
             || (triggerOnAllEvents() && state.isAdditionalEventPresentAfterDeleteEvent());
     state.markEventReceived(triggerOnAllEvents());
     retryAwareErrorLogging(state.getRetry(), eventPresent, exception, executionScope);
-    metrics.failedReconciliation(
+    metrics.reconciliationFailed(
         executionScope.getResource(), state.getRetry(), exception, metricsMetadata);
     if (eventPresent) {
       log.debug("New events exist for resource id");

operator-framework-core/src/test/java/io/javaoperatorsdk/operator/api/monitoring/AggregatedMetricsTest.java

@@ -73,36 +73,36 @@ void controllerRegistered_shouldDelegateToAllMetricsInOrder() {
   }
 
   @Test
-  void receivedEvent_shouldDelegateToAllMetricsInOrder() {
-    aggregatedMetrics.receivedEvent(event, metadata);
+  void eventReceived_shouldDelegateToAllMetricsInOrder() {
+    aggregatedMetrics.eventReceived(event, metadata);
 
     final var inOrder = inOrder(metrics1, metrics2, metrics3);
-    inOrder.verify(metrics1).receivedEvent(event, metadata);
-    inOrder.verify(metrics2).receivedEvent(event, metadata);
-    inOrder.verify(metrics3).receivedEvent(event, metadata);
+    inOrder.verify(metrics1).eventReceived(event, metadata);
+    inOrder.verify(metrics2).eventReceived(event, metadata);
+    inOrder.verify(metrics3).eventReceived(event, metadata);
     verifyNoMoreInteractions(metrics1, metrics2, metrics3);
   }
 
   @Test
-  void submittedForReconciliation_shouldDelegateToAllMetricsInOrder() {
-    aggregatedMetrics.submittedForReconciliation(resource, retryInfo, metadata);
+  void reconciliationSubmitted_shouldDelegateToAllMetricsInOrder() {
+    aggregatedMetrics.reconciliationSubmitted(resource, retryInfo, metadata);
 
     final var inOrder = inOrder(metrics1, metrics2, metrics3);
-    inOrder.verify(metrics1).submittedForReconciliation(resource, retryInfo, metadata);
-    inOrder.verify(metrics2).submittedForReconciliation(resource, retryInfo, metadata);
-    inOrder.verify(metrics3).submittedForReconciliation(resource, retryInfo, metadata);
+    inOrder.verify(metrics1).reconciliationSubmitted(resource, retryInfo, metadata);
+    inOrder.verify(metrics2).reconciliationSubmitted(resource, retryInfo, metadata);
+    inOrder.verify(metrics3).reconciliationSubmitted(resource, retryInfo, metadata);
     verifyNoMoreInteractions(metrics1, metrics2, metrics3);
   }
 
   @Test
-  void failedReconciliation_shouldDelegateToAllMetricsInOrder() {
+  void reconciliationFailed_shouldDelegateToAllMetricsInOrder() {
     final var exception = new RuntimeException("Test exception");
-    aggregatedMetrics.failedReconciliation(resource, retryInfo, exception, metadata);
+    aggregatedMetrics.reconciliationFailed(resource, retryInfo, exception, metadata);
 
     final var inOrder = inOrder(metrics1, metrics2, metrics3);
-    inOrder.verify(metrics1).failedReconciliation(resource, retryInfo, exception, metadata);
-    inOrder.verify(metrics2).failedReconciliation(resource, retryInfo, exception, metadata);
-    inOrder.verify(metrics3).failedReconciliation(resource, retryInfo, exception, metadata);
+    inOrder.verify(metrics1).reconciliationFailed(resource, retryInfo, exception, metadata);
+    inOrder.verify(metrics2).reconciliationFailed(resource, retryInfo, exception, metadata);
+    inOrder.verify(metrics3).reconciliationFailed(resource, retryInfo, exception, metadata);
     verifyNoMoreInteractions(metrics1, metrics2, metrics3);
   }
 
@@ -140,40 +140,40 @@ void cleanupDone_shouldDelegateToAllMetricsInOrder() {
   }
 
   @Test
-  void successfulReconciliation_shouldDelegateToAllMetricsInOrder() {
-    aggregatedMetrics.successfulReconciliation(resource, metadata);
+  void reconciliationSucceeded_shouldDelegateToAllMetricsInOrder() {
+    aggregatedMetrics.reconciliationSucceeded(resource, metadata);
 
     final var inOrder = inOrder(metrics1, metrics2, metrics3);
-    inOrder.verify(metrics1).successfulReconciliation(resource, metadata);
-    inOrder.verify(metrics2).successfulReconciliation(resource, metadata);
-    inOrder.verify(metrics3).successfulReconciliation(resource, metadata);
+    inOrder.verify(metrics1).reconciliationSucceeded(resource, metadata);
+    inOrder.verify(metrics2).reconciliationSucceeded(resource, metadata);
+    inOrder.verify(metrics3).reconciliationSucceeded(resource, metadata);
   }
 
   @Test
-  void timeControllerExecution_shouldOnlyDelegateToFirstMetrics() throws Exception {
+  void timedControllerExecution_shouldOnlyDelegateToFirstMetrics() throws Exception {
     final var expectedResult = "execution result";
-    when(metrics1.timeControllerExecution(controllerExecution)).thenReturn(expectedResult);
+    when(metrics1.timedControllerExecution(controllerExecution)).thenReturn(expectedResult);
 
-    final var result = aggregatedMetrics.timeControllerExecution(controllerExecution);
+    final var result = aggregatedMetrics.timedControllerExecution(controllerExecution);
 
     assertThat(result).isEqualTo(expectedResult);
-    verify(metrics1).timeControllerExecution(controllerExecution);
-    verify(metrics2, never()).timeControllerExecution(any());
-    verify(metrics3, never()).timeControllerExecution(any());
+    verify(metrics1).timedControllerExecution(controllerExecution);
+    verify(metrics2, never()).timedControllerExecution(any());
+    verify(metrics3, never()).timedControllerExecution(any());
     verifyNoMoreInteractions(metrics1, metrics2, metrics3);
   }
 
   @Test
-  void timeControllerExecution_shouldPropagateException() throws Exception {
+  void timedControllerExecution_shouldPropagateException() throws Exception {
     final var expectedException = new RuntimeException("Controller execution failed");
-    when(metrics1.timeControllerExecution(controllerExecution)).thenThrow(expectedException);
+    when(metrics1.timedControllerExecution(controllerExecution)).thenThrow(expectedException);
 
-    assertThatThrownBy(() -> aggregatedMetrics.timeControllerExecution(controllerExecution))
+    assertThatThrownBy(() -> aggregatedMetrics.timedControllerExecution(controllerExecution))
         .isSameAs(expectedException);
 
-    verify(metrics1).timeControllerExecution(controllerExecution);
-    verify(metrics2, never()).timeControllerExecution(any());
-    verify(metrics3, never()).timeControllerExecution(any());
+    verify(metrics1).timedControllerExecution(controllerExecution);
+    verify(metrics2, never()).timedControllerExecution(any());
+    verify(metrics3, never()).timedControllerExecution(any());
     verifyNoMoreInteractions(metrics1, metrics2, metrics3);
   }
 }