diff --git a/demos/roms-multi-acl-account/src/main/java/com/redis/romsmultiaclaccount/config/RedisConnectionFactoryConfig.java b/demos/roms-multi-acl-account/src/main/java/com/redis/romsmultiaclaccount/config/RedisConnectionFactoryConfig.java
index d904b0a3..8e416c34 100644
--- a/demos/roms-multi-acl-account/src/main/java/com/redis/romsmultiaclaccount/config/RedisConnectionFactoryConfig.java
+++ b/demos/roms-multi-acl-account/src/main/java/com/redis/romsmultiaclaccount/config/RedisConnectionFactoryConfig.java
@@ -27,6 +27,7 @@
 import com.redis.om.spring.RedisOMProperties;
 import com.redis.om.spring.client.RedisModulesClient;
 import com.redis.om.spring.indexing.RediSearchIndexer;
+import com.redis.om.spring.ops.CommandListener;
 import com.redis.om.spring.ops.RedisModulesOperations;
 import com.redis.om.spring.vectorize.Embedder;
 
@@ -120,8 +121,8 @@ public RedisModulesOperations<?> writeRedisModulesOperations(@Qualifier(
     "writeJedisConnectionFactory"
   ) JedisConnectionFactory factory, @Qualifier(
     "omGsonBuilder"
-  ) GsonBuilder builder) {
-    return new RedisModulesOperations<>(client, new StringRedisTemplate(factory), builder);
+  ) GsonBuilder builder, final CommandListener commandListener) {
+    return new RedisModulesOperations<>(client, new StringRedisTemplate(factory), builder, commandListener);
   }
 
   @Bean(
@@ -133,8 +134,8 @@ public RedisModulesOperations<?> readRedisModulesOperations(@Qualifier(
     "readJedisConnectionFactory"
   ) JedisConnectionFactory factory, @Qualifier(
     "omGsonBuilder"
-  ) GsonBuilder builder) {
-    return new RedisModulesOperations<>(client, new StringRedisTemplate(factory), builder);
+  ) GsonBuilder builder, final CommandListener commandListener) {
+    return new RedisModulesOperations<>(client, new StringRedisTemplate(factory), builder, commandListener);
   }
 
   @Bean(
diff --git a/redis-om-spring/src/main/java/com/redis/om/spring/RedisModulesConfiguration.java b/redis-om-spring/src/main/java/com/redis/om/spring/RedisModulesConfiguration.java
index f866b479..16b63cf3 100644
--- a/redis-om-spring/src/main/java/com/redis/om/spring/RedisModulesConfiguration.java
+++ b/redis-om-spring/src/main/java/com/redis/om/spring/RedisModulesConfiguration.java
@@ -42,6 +42,8 @@
 import com.redis.om.spring.client.RedisModulesClient;
 import com.redis.om.spring.indexing.RediSearchIndexer;
 import com.redis.om.spring.mapping.RedisEnhancedMappingContext;
+import com.redis.om.spring.ops.CommandListener;
+import com.redis.om.spring.ops.NoOpCommandListener;
 import com.redis.om.spring.ops.RedisModulesOperations;
 import com.redis.om.spring.ops.json.JSONOperations;
 import com.redis.om.spring.ops.pds.BloomOperations;
@@ -199,9 +201,10 @@ RedisModulesClient redisModulesClient( //
    * including JSON, Search, Bloom filters, and other probabilistic data structures.
    * It serves as the central operations hub for Redis OM Spring functionality.
    *
-   * @param rmc         the Redis modules client for low-level access
-   * @param template    the string Redis template for basic operations
-   * @param gsonBuilder the Gson builder for JSON serialization
+   * @param rmc             the Redis modules client for low-level access
+   * @param template        the string Redis template for basic operations
+   * @param gsonBuilder     the Gson builder for JSON serialization
+   * @param commandListener a command listener for monitoring Redis commands
    * @return the Redis modules operations instance
    */
   @Bean(
@@ -215,8 +218,25 @@ RedisModulesOperations<?> redisModulesOperations( //
       StringRedisTemplate template, //
       @Qualifier(
         "omGsonBuilder"
-      ) GsonBuilder gsonBuilder) {
-    return new RedisModulesOperations<>(rmc, template, gsonBuilder);
+      ) GsonBuilder gsonBuilder, final CommandListener commandListener) {
+    return new RedisModulesOperations<>(rmc, template, gsonBuilder, commandListener);
+  }
+
+  /**
+   * Provides a default implementation of the CommandListener bean.
+   * <p>
+   * This method creates a no-operation (NoOp) implementation of the CommandListener interface.
+   * It is used as a fallback when no other CommandListener bean is defined in the application context.
+   * <p>
+   * The {@code @Fallback} annotation ensures that this bean is only used when no other
+   * CommandListener bean is available, allowing developers to override it with a custom implementation if needed.
+   *
+   * @return a NoOpCommandListener instance, which performs no operations.
+   */
+  @Bean
+  @Fallback
+  public CommandListener commandListener() {
+    return new NoOpCommandListener();
   }
 
   /**
diff --git a/redis-om-spring/src/main/java/com/redis/om/spring/ops/CommandListener.java b/redis-om-spring/src/main/java/com/redis/om/spring/ops/CommandListener.java
new file mode 100644
index 00000000..60d41aed
--- /dev/null
+++ b/redis-om-spring/src/main/java/com/redis/om/spring/ops/CommandListener.java
@@ -0,0 +1,165 @@
+package com.redis.om.spring.ops;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import com.redis.om.spring.autocomplete.Suggestion;
+import com.redis.om.spring.repository.query.autocomplete.AutoCompleteOptions;
+
+import redis.clients.jedis.search.FTCreateParams;
+import redis.clients.jedis.search.FTSearchParams;
+import redis.clients.jedis.search.IndexOptions;
+import redis.clients.jedis.search.Query;
+import redis.clients.jedis.search.Schema;
+import redis.clients.jedis.search.SearchProtocol;
+import redis.clients.jedis.search.SearchResult;
+import redis.clients.jedis.search.aggr.AggregationBuilder;
+import redis.clients.jedis.search.aggr.AggregationResult;
+import redis.clients.jedis.search.schemafields.SchemaField;
+
+public interface CommandListener {
+  default void searchStarted(String indexName, Query q, FTSearchParams params) {
+  }
+
+  default void searchFinished(String indexName, Query q, FTSearchParams params, SearchResult searchResult) {
+  }
+
+  default void createIndexStarted(String indexName, FTCreateParams params, List<SchemaField> fields, Schema schema,
+      IndexOptions options) {
+  }
+
+  default void createIndexFinished(String indexName, FTCreateParams params, List<SchemaField> fields, Schema schema,
+      IndexOptions options, String result) {
+  }
+
+  default void aggregateStarted(String indexName, AggregationBuilder q) {
+  }
+
+  default void aggregateFinished(String indexName, AggregationBuilder q, AggregationResult result) {
+  }
+
+  default void cursorDeleteStarted(String string, long cursorId) {
+  }
+
+  default void cursorDeleteFinished(String string, long cursorId, String result) {
+  }
+
+  default void cursorReadStarted(String string, long cursorId, int count) {
+  }
+
+  default void cursorReadFinished(String string, long cursorId, int count, AggregationResult aggregationResult) {
+  }
+
+  default void explainStarted(String string, Query q) {
+  }
+
+  default void explainFinished(String string, Query q, String s) {
+  }
+
+  default void infoStarted(String string) {
+  }
+
+  default void infoFinished(String string, Map<String, Object> stringObjectMap) {
+  }
+
+  default void dropIndexStarted(String string) {
+  }
+
+  default void dropIndexFinished(String string, String result) {
+  }
+
+  default void dropIndexAndDocumentsStarted(String string) {
+  }
+
+  default void dropIndexAndDocumentsFinished(String string, String result) {
+  }
+
+  default void addSuggestionStarted(String string, String key, String suggestion, double score) {
+  }
+
+  default void addSuggestionFinished(String string, String key, String suggestion, double score, long result) {
+  }
+
+  default void getSuggestionStarted(String string, String key, String prefix, AutoCompleteOptions options) {
+  }
+
+  default void getSuggestionFinished(String string, String key, String prefix, AutoCompleteOptions options,
+      List<Suggestion> list) {
+  }
+
+  default void deleteSuggestionStarted(String string, String key, String entry) {
+  }
+
+  default void deleteSuggestionFinished(String string, String key, String entry, boolean result) {
+  }
+
+  default void getSuggestionLengthStarted(String string, String key) {
+  }
+
+  default void getSuggestionLengthFinished(String string, String key, long result) {
+  }
+
+  default void alterIndexStarted(String string, SchemaField[] fields) {
+  }
+
+  default void alterIndexFinished(String string, SchemaField[] fields, String result) {
+  }
+
+  default void setConfigStarted(String string, String option, String value) {
+  }
+
+  default void setConfigFinished(String string, String option, String value, String result) {
+  }
+
+  default void getConfigStarted(String string, String option) {
+  }
+
+  default void getConfigFinished(String string, String option, Map<String, Object> result) {
+  }
+
+  default void getIndexConfigStarted(String string, String option) {
+  }
+
+  default void getIndexConfigFinished(String string, String option, Map<String, Object> result) {
+  }
+
+  default void addAliasStarted(String string, String name) {
+  }
+
+  default void addAliasFinished(String string, String name, String result) {
+  }
+
+  default void updateAliasStarted(String string, String name) {
+  }
+
+  default void updateAliasFinished(String string, String name, String result) {
+  }
+
+  default void deleteAliasStarted(String string, String name) {
+  }
+
+  default void deleteAliasFinished(String string, String name, String result) {
+  }
+
+  default void updateSynonymStarted(String string, String synonymGroupId, String[] terms) {
+  }
+
+  default void updateSynonymFinished(String string, String synonymGroupId, String[] terms, String result) {
+  }
+
+  default void dumpSynonymStarted(String string) {
+  }
+
+  default void dumpSynonymFinished(String string, Map<String, List<String>> result) {
+  }
+
+  default void tagValsStarted(String string, String field) {
+  }
+
+  default void tagValsFinished(String string, String field, Set<String> result) {
+  }
+
+  default void commandFailed(SearchProtocol.SearchCommand command, String indexName, Throwable t) {
+  }
+}
diff --git a/redis-om-spring/src/main/java/com/redis/om/spring/ops/NoOpCommandListener.java b/redis-om-spring/src/main/java/com/redis/om/spring/ops/NoOpCommandListener.java
new file mode 100644
index 00000000..bfead3ea
--- /dev/null
+++ b/redis-om-spring/src/main/java/com/redis/om/spring/ops/NoOpCommandListener.java
@@ -0,0 +1,4 @@
+package com.redis.om.spring.ops;
+
+public class NoOpCommandListener implements CommandListener {
+}
diff --git a/redis-om-spring/src/main/java/com/redis/om/spring/ops/RedisModulesOperations.java b/redis-om-spring/src/main/java/com/redis/om/spring/ops/RedisModulesOperations.java
index 3539058a..2b1b019d 100644
--- a/redis-om-spring/src/main/java/com/redis/om/spring/ops/RedisModulesOperations.java
+++ b/redis-om-spring/src/main/java/com/redis/om/spring/ops/RedisModulesOperations.java
@@ -22,11 +22,12 @@
  * and provides typed access to module-specific operations through the {@code opsFor*} methods.
  * </p>
  *
- * @param <K>         the type of keys used in Redis operations
- * @param client      the Redis modules client for executing commands
- * @param template    the Spring Data Redis template for additional Redis operations
- * @param gsonBuilder the Gson builder for JSON serialization/deserialization configuration
- * 
+ * @param <K>             the type of keys used in Redis operations
+ * @param client          the Redis modules client for executing commands
+ * @param template        the Spring Data Redis template for additional Redis operations
+ * @param gsonBuilder     the Gson builder for JSON serialization/deserialization configuration
+ * @param commandListener A command listener for monitoring Redis commands
+ *
  * @author Redis OM Spring Team
  * @see JSONOperations
  * @see SearchOperations
@@ -37,7 +38,7 @@
  * @see TDigestOperations
  */
 public record RedisModulesOperations<K>(RedisModulesClient client, StringRedisTemplate template,
-                                        GsonBuilder gsonBuilder) {
+                                        GsonBuilder gsonBuilder, CommandListener commandListener) {
 
   /**
    * Creates and returns operations for interacting with RedisJSON module.
@@ -65,7 +66,7 @@ public JSONOperations<K> opsForJSON() {
    * @return a {@link SearchOperations} instance for search and indexing operations
    */
   public SearchOperations<K> opsForSearch(K index) {
-    return new SearchOperationsImpl<>(index, client, template);
+    return new SearchOperationsImpl<>(index, client, template, commandListener);
   }
 
   /**
diff --git a/redis-om-spring/src/main/java/com/redis/om/spring/ops/search/SearchOperationsImpl.java b/redis-om-spring/src/main/java/com/redis/om/spring/ops/search/SearchOperationsImpl.java
index 19fdc18a..afd766bf 100644
--- a/redis-om-spring/src/main/java/com/redis/om/spring/ops/search/SearchOperationsImpl.java
+++ b/redis-om-spring/src/main/java/com/redis/om/spring/ops/search/SearchOperationsImpl.java
@@ -10,6 +10,7 @@
 import com.google.gson.reflect.TypeToken;
 import com.redis.om.spring.autocomplete.Suggestion;
 import com.redis.om.spring.client.RedisModulesClient;
+import com.redis.om.spring.ops.CommandListener;
 import com.redis.om.spring.repository.query.autocomplete.AutoCompleteOptions;
 
 import redis.clients.jedis.resps.Tuple;
@@ -39,84 +40,191 @@ public class SearchOperationsImpl<K> implements SearchOperations<K> {
   private final RedisModulesClient modulesClient;
   private final K index;
   private final StringRedisTemplate template;
+  private final CommandListener commandListener;
 
   /**
    * Creates a new search operations implementation.
    *
-   * @param index         the search index identifier
-   * @param modulesClient the Redis modules client for search operations
-   * @param template      the string Redis template for additional operations
+   * @param index           the search index identifier
+   * @param modulesClient   the Redis modules client for search operations
+   * @param template        the string Redis template for additional operations
+   * @param commandListener A command listener for monitoring Redis commands
    */
-  public SearchOperationsImpl(K index, RedisModulesClient modulesClient, StringRedisTemplate template) {
+  public SearchOperationsImpl(K index, RedisModulesClient modulesClient, StringRedisTemplate template,
+      final CommandListener commandListener) {
     this.index = index;
     this.modulesClient = modulesClient;
     this.search = modulesClient.clientForSearch();
     this.template = template;
+    this.commandListener = commandListener;
   }
 
   @Override
   public String createIndex(Schema schema, IndexOptions options) {
-    return search.ftCreate(index.toString(), options, schema);
+    commandListener.createIndexStarted(index.toString(), null, null, schema, options);
+    String result = null;
+    try {
+      result = search.ftCreate(index.toString(), options, schema);
+    } catch (Exception e) {
+      throw e;
+    } finally {
+      commandListener.createIndexFinished(index.toString(), null, null, schema, options, result);
+    }
+    return result;
   }
 
   @Override
   public String createIndex(FTCreateParams params, List<SchemaField> fields) {
-    return search.ftCreate(index.toString(), params, fields);
+    commandListener.createIndexStarted(index.toString(), params, fields, null, null);
+    String result = null;
+    try {
+      result = search.ftCreate(index.toString(), params, fields);
+    } catch (Exception e) {
+      throw e;
+    } finally {
+      commandListener.createIndexFinished(index.toString(), params, fields, null, null, result);
+    }
+    return result;
   }
 
   @Override
+  @Deprecated
   public SearchResult search(Query q) {
-    return search.ftSearch(SafeEncoder.encode(index.toString()), q);
+    commandListener.searchStarted(index.toString(), q, null);
+    SearchResult result = null;
+    try {
+      result = search.ftSearch(SafeEncoder.encode(index.toString()), q);
+    } catch (Exception e) {
+      throw e;
+    } finally {
+      commandListener.searchFinished(index.toString(), q, null, result);
+    }
+    return result;
   }
 
   @Override
   public SearchResult search(Query q, FTSearchParams params) {
-    return search.ftSearch(index.toString(), q.toString(), params);
+    commandListener.searchStarted(index.toString(), q, null);
+    final SearchResult result = search.ftSearch(index.toString(), q.toString(), params);
+    commandListener.searchFinished(index.toString(), q, null, result);
+    return result;
   }
 
   @Override
   public AggregationResult aggregate(AggregationBuilder q) {
-    return search.ftAggregate(index.toString(), q);
+    commandListener.aggregateStarted(index.toString(), q);
+    AggregationResult result = null;
+    try {
+      result = search.ftAggregate(index.toString(), q);
+    } catch (Exception e) {
+      throw e;
+    } finally {
+      commandListener.aggregateFinished(index.toString(), q, result);
+    }
+    return result;
   }
 
   @Override
   public String cursorDelete(long cursorId) {
-    return search.ftCursorDel(index.toString(), cursorId);
+    commandListener.cursorDeleteStarted(index.toString(), cursorId);
+    String result = null;
+    try {
+      result = search.ftCursorDel(index.toString(), cursorId);
+    } catch (Exception e) {
+      throw e;
+    } finally {
+      commandListener.cursorDeleteFinished(index.toString(), cursorId, result);
+    }
+    return result;
   }
 
   @Override
   public AggregationResult cursorRead(long cursorId, int count) {
-    return search.ftCursorRead(index.toString(), cursorId, count);
+    commandListener.cursorReadStarted(index.toString(), cursorId, count);
+    AggregationResult result = null;
+    try {
+      result = search.ftCursorRead(index.toString(), cursorId, count);
+    } catch (Exception e) {
+      throw e;
+    } finally {
+      commandListener.cursorReadFinished(index.toString(), cursorId, count, result);
+    }
+    return result;
   }
 
   @Override
   public String explain(Query q) {
-    return search.ftExplain(index.toString(), q);
+    commandListener.explainStarted(index.toString(), q);
+    String result = null;
+    try {
+      result = search.ftExplain(index.toString(), q);
+    } catch (Exception e) {
+      throw e;
+    } finally {
+      commandListener.explainFinished(index.toString(), q, result);
+    }
+    return result;
   }
 
   @Override
   public Map<String, Object> getInfo() {
-    return search.ftInfo(index.toString());
+    commandListener.infoStarted(index.toString());
+    Map<String, Object> result = Map.of();
+    try {
+      result = search.ftInfo(index.toString());
+    } catch (Exception e) {
+      throw e;
+    } finally {
+      commandListener.infoFinished(index.toString(), result);
+    }
+    return result;
   }
 
   @Override
   public String dropIndex() {
-    return search.ftDropIndex(index.toString());
+    commandListener.dropIndexStarted(index.toString());
+    String result = null;
+    try {
+      result = search.ftDropIndex(index.toString());
+    } catch (Exception e) {
+      throw e;
+    } finally {
+      commandListener.dropIndexFinished(index.toString(), result);
+    }
+    return result;
   }
 
   @Override
   public String dropIndexAndDocuments() {
-    return search.ftDropIndexDD(index.toString());
+    commandListener.dropIndexAndDocumentsStarted(index.toString());
+    String result = null;
+    try {
+      result = search.ftDropIndexDD(index.toString());
+    } catch (Exception e) {
+      throw e;
+    } finally {
+      commandListener.dropIndexAndDocumentsFinished(index.toString(), result);
+    }
+    return result;
   }
 
   @Override
   public Long addSuggestion(String key, String suggestion) {
-    return search.ftSugAdd(key, suggestion, 1.0);
+    return addSuggestion(key, suggestion, 1.0);
   }
 
   @Override
   public Long addSuggestion(String key, String suggestion, double score) {
-    return search.ftSugAdd(key, suggestion, score);
+    commandListener.addSuggestionStarted(index.toString(), key, suggestion, score);
+    long result = 0;
+    try {
+      result = search.ftSugAdd(key, suggestion, score);
+    } catch (Exception e) {
+      throw e;
+    } finally {
+      commandListener.addSuggestionFinished(index.toString(), key, suggestion, score, result);
+    }
+    return result;
   }
 
   @Override
@@ -126,101 +234,226 @@ public List<Suggestion> getSuggestion(String key, String prefix) {
 
   @Override
   public List<Suggestion> getSuggestion(String key, String prefix, AutoCompleteOptions options) {
+    commandListener.getSuggestionStarted(index.toString(), key, prefix, options);
     Gson gson = modulesClient.gsonBuilder().create();
 
     if (options.isWithScore()) {
       List<Tuple> suggestions = search.ftSugGetWithScores(key, prefix, options.isFuzzy(), options.getLimit());
-      return suggestions.stream().map(suggestion -> {
-        if (options.isWithPayload()) {
-          String[] keyParts = key.split(":");
-          String payLoadKey = String.format("sugg:payload:%s:%s", keyParts[keyParts.length - 2],
-              keyParts[keyParts.length - 1]);
-          Object payload = template.opsForHash().get(payLoadKey, suggestion.getElement());
-          String json = payload != null ? payload.toString() : "{}";
-          Map<String, Object> payloadMap = gson.fromJson(json, new TypeToken<Map<String, Object>>() {
-          }.getType());
-          return new Suggestion(suggestion.getElement(), suggestion.getScore(), payloadMap);
-        } else {
-          return new Suggestion(suggestion.getElement(), suggestion.getScore());
-        }
-      }).toList();
+      List<Suggestion> list = List.of();
+      try {
+        list = suggestions.stream().map(suggestion -> {
+          if (options.isWithPayload()) {
+            String[] keyParts = key.split(":");
+            String payLoadKey = String.format("sugg:payload:%s:%s", keyParts[keyParts.length - 2],
+                keyParts[keyParts.length - 1]);
+            Object payload = template.opsForHash().get(payLoadKey, suggestion.getElement());
+            String json = payload != null ? payload.toString() : "{}";
+            Map<String, Object> payloadMap = gson.fromJson(json, new TypeToken<Map<String, Object>>() {
+            }.getType());
+            return new Suggestion(suggestion.getElement(), suggestion.getScore(), payloadMap);
+          } else {
+            return new Suggestion(suggestion.getElement(), suggestion.getScore());
+          }
+        }).toList();
+      } catch (Exception e) {
+        throw e;
+      } finally {
+        commandListener.getSuggestionFinished(index.toString(), key, prefix, options, list);
+      }
+      return list;
     } else {
       List<String> suggestions = search.ftSugGet(key, prefix, options.isFuzzy(), options.getLimit());
-      return suggestions.stream().map(suggestion -> {
-        if (options.isWithPayload()) {
-          String[] keyParts = key.split(":");
-          String payLoadKey = String.format("sugg:payload:%s:%s", keyParts[keyParts.length - 2],
-              keyParts[keyParts.length - 1]);
-          Object payload = template.opsForHash().get(payLoadKey, suggestion);
-          String json = payload != null ? payload.toString() : "{}";
-          Map<String, Object> payloadMap = gson.fromJson(json, new TypeToken<Map<String, Object>>() {
-          }.getType());
-          return new Suggestion(suggestion, payloadMap);
-        } else {
-          return new Suggestion(suggestion);
-        }
-      }).toList();
+      List<Suggestion> list = List.of();
+      try {
+        list = suggestions.stream().map(suggestion -> {
+          if (options.isWithPayload()) {
+            String[] keyParts = key.split(":");
+            String payLoadKey = String.format("sugg:payload:%s:%s", keyParts[keyParts.length - 2],
+                keyParts[keyParts.length - 1]);
+            Object payload = template.opsForHash().get(payLoadKey, suggestion);
+            String json = payload != null ? payload.toString() : "{}";
+            Map<String, Object> payloadMap = gson.fromJson(json, new TypeToken<Map<String, Object>>() {
+            }.getType());
+            return new Suggestion(suggestion, payloadMap);
+          } else {
+            return new Suggestion(suggestion);
+          }
+        }).toList();
+      } catch (Exception e) {
+        throw e;
+      } finally {
+        commandListener.getSuggestionFinished(index.toString(), key, prefix, options, list);
+      }
+      return list;
     }
   }
 
   @Override
   public Boolean deleteSuggestion(String key, String entry) {
-    return search.ftSugDel(key, entry);
+    commandListener.deleteSuggestionStarted(index.toString(), key, entry);
+    boolean result = false;
+    try {
+      result = search.ftSugDel(key, entry);
+    } catch (Exception e) {
+      throw e;
+    } finally {
+      commandListener.deleteSuggestionFinished(index.toString(), key, entry, result);
+    }
+    return result;
   }
 
   @Override
   public Long getSuggestionLength(String key) {
-    return search.ftSugLen(key);
+    commandListener.getSuggestionLengthStarted(index.toString(), key);
+    long result = 0;
+    try {
+      result = search.ftSugLen(key);
+    } catch (Exception e) {
+      throw e;
+    } finally {
+      commandListener.getSuggestionLengthFinished(index.toString(), key, result);
+    }
+    return result;
   }
 
   @Override
   public String alterIndex(SchemaField... fields) {
-    return search.ftAlter(index.toString(), fields);
+    commandListener.alterIndexStarted(index.toString(), fields);
+    String result = null;
+    try {
+      result = search.ftAlter(index.toString(), fields);
+    } catch (Exception e) {
+      throw e;
+    } finally {
+      commandListener.alterIndexFinished(index.toString(), fields, result);
+    }
+    return result;
   }
 
   @Override
   public String setConfig(String option, String value) {
-    return search.ftConfigSet(option, value);
+    commandListener.setConfigStarted(index.toString(), option, value);
+    String result = null;
+    try {
+      result = search.ftConfigSet(option, value);
+    } catch (Exception e) {
+      throw e;
+    } finally {
+      commandListener.setConfigFinished(index.toString(), option, value, result);
+    }
+    return result;
   }
 
   @Override
   public Map<String, Object> getConfig(String option) {
-    return search.ftConfigGet(option);
+    commandListener.getConfigStarted(index.toString(), option);
+    Map<String, Object> result = Map.of();
+    try {
+      result = search.ftConfigGet(option);
+    } catch (Exception e) {
+      throw e;
+    } finally {
+      commandListener.getConfigFinished(index.toString(), option, result);
+    }
+    return result;
   }
 
   @Override
   public Map<String, Object> getIndexConfig(String option) {
-    return search.ftConfigGet(index.toString(), option);
+    commandListener.getIndexConfigStarted(index.toString(), option);
+    Map<String, Object> result = Map.of();
+    try {
+      result = search.ftConfigGet(index.toString(), option);
+    } catch (Exception e) {
+      throw e;
+    } finally {
+      commandListener.getIndexConfigFinished(index.toString(), option, result);
+    }
+    return result;
   }
 
   @Override
   public String addAlias(String name) {
-    return search.ftAliasAdd(name, index.toString());
+    commandListener.addAliasStarted(index.toString(), name);
+    String result = null;
+    try {
+      result = search.ftAliasAdd(name, index.toString());
+    } catch (Exception e) {
+      throw e;
+    } finally {
+      commandListener.addAliasFinished(index.toString(), name, result);
+    }
+    return result;
   }
 
   @Override
   public String updateAlias(String name) {
-    return search.ftAliasUpdate(name, index.toString());
+    commandListener.updateAliasStarted(index.toString(), name);
+    String result = null;
+    try {
+      result = search.ftAliasUpdate(name, index.toString());
+    } catch (Exception e) {
+      throw e;
+    } finally {
+      commandListener.updateAliasFinished(index.toString(), name, result);
+    }
+    return result;
   }
 
   @Override
   public String deleteAlias(String name) {
-    return search.ftAliasDel(name);
+    commandListener.deleteAliasStarted(index.toString(), name);
+    String result = null;
+    try {
+      result = search.ftAliasDel(name);
+    } catch (Exception e) {
+      throw e;
+    } finally {
+      commandListener.deleteAliasFinished(index.toString(), name, result);
+    }
+    return result;
   }
 
   @Override
   public String updateSynonym(String synonymGroupId, String... terms) {
-    return search.ftSynUpdate(index.toString(), synonymGroupId, terms);
+    commandListener.updateSynonymStarted(index.toString(), synonymGroupId, terms);
+    String result = null;
+    try {
+      result = search.ftSynUpdate(index.toString(), synonymGroupId, terms);
+    } catch (Exception e) {
+      throw e;
+    } finally {
+      commandListener.updateSynonymFinished(index.toString(), synonymGroupId, terms, result);
+    }
+    return result;
   }
 
   @Override
   public Map<String, List<String>> dumpSynonym() {
-    return search.ftSynDump(index.toString());
+    commandListener.dumpSynonymStarted(index.toString());
+    Map<String, List<String>> result = Map.of();
+    try {
+      result = search.ftSynDump(index.toString());
+    } catch (Exception e) {
+      throw e;
+    } finally {
+      commandListener.dumpSynonymFinished(index.toString(), result);
+    }
+    return result;
   }
 
   @Override
   public Set<String> tagVals(String field) {
-    return search.ftTagVals(index.toString(), field);
+    commandListener.tagValsStarted(index.toString(), field);
+    Set<String> result = Set.of();
+    try {
+      result = search.ftTagVals(index.toString(), field);
+    } catch (Exception e) {
+      throw e;
+    } finally {
+      commandListener.tagValsFinished(index.toString(), field, result);
+    }
+    return result;
   }
 
 }
diff --git a/tests/src/test/java/com/redis/om/spring/ops/CommandListenerTest.java b/tests/src/test/java/com/redis/om/spring/ops/CommandListenerTest.java
new file mode 100644
index 00000000..c4001c96
--- /dev/null
+++ b/tests/src/test/java/com/redis/om/spring/ops/CommandListenerTest.java
@@ -0,0 +1,284 @@
+package com.redis.om.spring.ops;
+
+import com.redis.om.spring.AbstractBaseDocumentTest;
+import com.redis.om.spring.ops.search.SearchOperations;
+import lombok.extern.slf4j.Slf4j;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+import org.springframework.beans.factory.annotation.Autowired;
+import redis.clients.jedis.search.FTCreateParams;
+import redis.clients.jedis.search.IndexDataType;
+import redis.clients.jedis.search.Query;
+import redis.clients.jedis.search.SearchResult;
+import redis.clients.jedis.search.aggr.AggregationBuilder;
+import redis.clients.jedis.search.aggr.AggregationResult;
+import redis.clients.jedis.search.schemafields.SchemaField;
+import redis.clients.jedis.search.schemafields.TextField;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+@Slf4j
+class CommandListenerTest extends AbstractBaseDocumentTest {
+    @Autowired
+    private RedisModulesOperations<String> modulesOperations;
+
+    @Autowired
+    private TestCommandListener testListener;
+
+    @BeforeEach
+    void setUp() {
+      testListener.reset();
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = { "test-create-index", "another-create-index", "yet-another-create-index" })
+    void givenIndexName_whenCreateAndDropIndex_thenAssertResult(final String indexName) {
+        // Given
+        final String idx = indexName + "-" + UUID.randomUUID();
+        // When
+        final SearchOperations<String> searchOps = createIndex(idx);
+        // Then
+        final String result = searchOps.dropIndex();
+        // Then
+        assertNotNull(result);
+        assertEquals(2, testListener.dropIndexStartedCount.get());
+        assertEquals(2, testListener.dropIndexFinishedCount.get());
+        assertEquals(idx, testListener.lastDropIndexName);
+        assertEquals(result, testListener.lastDropIndexResult);
+    }
+
+    @Test
+    void given_whenSearch_thenAssertResult() {
+        // Given
+        final String indexName = "test-search-index-" + UUID.randomUUID();
+        final SearchOperations<String> searchOps = createIndex(indexName);
+        // Insert test data
+        final String doc1Key = indexName + ":doc1";
+        final String doc2Key = indexName + ":doc2";
+        final String doc3Key = indexName + ":doc3";
+        template.opsForHash().put(doc1Key, "content", "The quick brown fox");
+        template.opsForHash().put(doc2Key, "content", "jumps over the lazy dog");
+        template.opsForHash().put(doc3Key, "content", "Redis search is powerful");
+        // When
+        final Query query = new Query("fox");
+        final SearchResult result = searchOps.search(query);
+        // Then
+        assertEquals(1, testListener.searchStartedCount.get());
+        assertEquals(1, testListener.searchFinishedCount.get());
+        assertEquals(indexName, testListener.lastSearchIndexName);
+        assertEquals(query, testListener.lastSearchQuery);
+        assertEquals(result, testListener.lastSearchResult);
+        assertEquals(1, result.getTotalResults());
+        assertNotNull(result.getDocuments());
+        assertEquals(1, result.getDocuments().size());
+        assertEquals(doc1Key, result.getDocuments().getFirst().getId());
+        assertEquals("The quick brown fox", result.getDocuments().getFirst().getString("content"));
+        template.delete(doc1Key);
+        template.delete(doc2Key);
+        template.delete(doc3Key);
+    }
+
+    @Test
+    void given_whenAggregate_thenAssertResult() {
+        // Given
+        final String indexName = "test-aggregate-index-" + UUID.randomUUID();
+        final SearchOperations<String> searchOps = createIndex(indexName);
+        // Insert test data for aggregation
+        template.opsForHash().put(indexName + ":doc1", "content", "Java programming");
+        template.opsForHash().put(indexName + ":doc2", "content", "Python programming");
+        template.opsForHash().put(indexName + ":doc3", "content", "Redis database");
+        // When
+        final AggregationBuilder aggBuilder = new AggregationBuilder("*");
+        final AggregationResult aggResult = searchOps.aggregate(aggBuilder);
+        // Then
+        assertNotNull(aggResult);
+        assertEquals(1, aggResult.getTotalResults());
+        assertEquals(1, testListener.aggregateStartedCount.get());
+        assertEquals(1, testListener.aggregateFinishedCount.get());
+        assertEquals(indexName, testListener.lastAggregateIndexName);
+        assertEquals(aggBuilder, testListener.lastAggregationBuilder);
+        template.delete(indexName + ":doc1");
+        template.delete(indexName + ":doc2");
+        template.delete(indexName + ":doc3");
+    }
+
+    @Test
+    void given_whenGetInfo_thenAssertResult() {
+        // Given
+        final String indexName = "test-info-index-" + UUID.randomUUID();
+        final SearchOperations<String> searchOps = createIndex(indexName);
+        // When
+        final Map<String, Object> infoResult = searchOps.getInfo();
+        // Then
+        assertNotNull(infoResult);
+        assertThat(infoResult).isNotEmpty();
+        assertEquals(1, testListener.infoStartedCount.get());
+        assertEquals(1, testListener.infoFinishedCount.get());
+    }
+
+    @Test
+    void given_whenExplainQuery_thenAssertResult() {
+        // Given
+        final String indexName = "test-explain-index-" + UUID.randomUUID();
+        final SearchOperations<String> searchOps = createIndex(indexName);
+        // When
+        final Query query = new Query("*");
+        final String explanation = searchOps.explain(query);
+        // Then
+        assertNotNull(explanation);
+        assertEquals("<WILDCARD>\n", explanation);
+    }
+
+    @Test
+    void given_whenAlterIndex_thenAssertResult() {
+        // Given
+        final String indexName = "test-alter-index-" + UUID.randomUUID();
+        final SearchOperations<String> searchOps = createIndex(indexName);
+        // When
+        final SchemaField newField = TextField.of("newfield");
+        final String result = searchOps.alterIndex(newField);
+        // Then
+        assertEquals("OK", result);
+        assertEquals(1, testListener.alterIndexStartedCount.get());
+        assertEquals(1, testListener.alterIndexFinishedCount.get());
+    }
+
+    @Test
+    void given_whenDropIndexAndDocuments_thenAssertResult() {
+        // Given
+        final String indexName = "test-drop-docs-index-" + UUID.randomUUID();
+        final SearchOperations<String> searchOps = createIndex(indexName);
+        // Insert test data
+        final String doc1Key = indexName + ":doc1";
+        final String doc2Key = indexName + ":doc2";
+        final String doc3Key = indexName + ":doc3";
+        template.opsForHash().put(doc1Key, "content", "The quick brown fox");
+        template.opsForHash().put(doc2Key, "content", "jumps over the lazy dog");
+        template.opsForHash().put(doc3Key, "content", "Redis search is powerful");
+        // When
+        final String result = searchOps.dropIndexAndDocuments();
+        // Then
+        assertEquals("OK", result);
+        assertEquals(1, testListener.dropIndexAndDocumentsStartedCount.get());
+        assertEquals(1, testListener.dropIndexAndDocumentsFinishedCount.get());
+        template.delete(doc1Key);
+        template.delete(doc2Key);
+        template.delete(doc3Key);
+        assertEquals(0, template.opsForHash().keys(doc1Key).size());
+        assertEquals(0, template.opsForHash().keys(doc2Key).size());
+        assertEquals(0, template.opsForHash().keys(doc3Key).size());
+    }
+
+    @Test
+    void given_whenAddUpdateDeleteAlias_thenAssertResult() {
+        // Given
+        final String indexName = "test-add-alias-index-" + UUID.randomUUID();
+        final SearchOperations<String> searchOps = createIndex(indexName);
+        // Insert test data
+        final String doc1Key = indexName + ":doc1";
+        final String doc2Key = indexName + ":doc2";
+        final String doc3Key = indexName + ":doc3";
+        template.opsForHash().put(doc1Key, "content", "The quick brown fox");
+        template.opsForHash().put(doc2Key, "content", "jumps over the lazy dog");
+        template.opsForHash().put(doc3Key, "content", "Redis search is powerful");
+        final String newIndexName = UUID.randomUUID().toString();
+        // When addAlias
+        String result = searchOps.addAlias(newIndexName);
+        // Then addAlias
+        assertEquals("OK", result);
+        assertEquals(1, testListener.addAliasStartedCount.get());
+        assertEquals(1, testListener.addAliasFinishedCount.get());
+        // When updateAlias
+        result = searchOps.updateAlias(newIndexName);
+        // Then updateAlias
+        assertEquals("OK", result);
+        assertEquals(1, testListener.updateAliasStartedCount.get());
+        assertEquals(1, testListener.updateAliasFinishedCount.get());
+        // When deleteAlias
+        result = searchOps.deleteAlias(newIndexName);
+        // Then deleteAlias
+        assertEquals("OK", result);
+        assertEquals(1, testListener.deleteAliasStartedCount.get());
+        assertEquals(1, testListener.deleteAliasFinishedCount.get());
+        template.delete(doc1Key);
+        template.delete(doc2Key);
+        template.delete(doc3Key);
+        assertEquals(0, template.opsForHash().keys(doc1Key).size());
+        assertEquals(0, template.opsForHash().keys(doc2Key).size());
+        assertEquals(0, template.opsForHash().keys(doc3Key).size());
+    }
+
+    @Test
+    void given_whenGetConfig_thenAssertResult() {
+        // Given
+        final String indexName = "test-get-config-index-" + UUID.randomUUID();
+        final SearchOperations<String> searchOps = createIndex(indexName);
+        // When
+        final Map<String, Object> result = searchOps.getConfig("*");
+        // Then
+        assertNotNull(result);
+        assertFalse(result.isEmpty());
+        assertEquals(1, testListener.getConfigStartedCount.get());
+        assertEquals(1, testListener.getConfigFinishedCount.get());
+    }
+
+    @Test
+    void given_whenGetIndexConfig_thenAssertResult() {
+        // Given
+        final String indexName = "test-get-config-index-" + UUID.randomUUID();
+        final SearchOperations<String> searchOps = createIndex(indexName);
+        // When
+        final Map<String, Object> result = searchOps.getIndexConfig("*");
+        // Then
+        assertNotNull(result);
+        assertFalse(result.isEmpty());
+        assertEquals(1, testListener.getIndexConfigStartedCount.get());
+        assertEquals(1, testListener.getIndexConfigFinishedCount.get());
+    }
+
+    @Test
+    void given_whenSetConfig_thenAssertResult() {
+        // Given
+        final String indexName = "test-get-config-index-" + UUID.randomUUID();
+        final SearchOperations<String> searchOps = createIndex(indexName);
+        // When
+        final String result = searchOps.setConfig("TIMEOUT", "42");
+        // Then
+        assertEquals("OK", result);
+        assertEquals(1, testListener.setConfigStartedCount.get());
+        assertEquals(1, testListener.setConfigFinishedCount.get());
+        final Map<String, Object> getTimeout = searchOps.getConfig("TIMEOUT");
+        assertEquals("42", getTimeout.get("TIMEOUT").toString());
+    }
+
+    private SearchOperations<String> createIndex(final String indexName) {
+        // Given
+        final SearchOperations<String> searchOps = modulesOperations.opsForSearch(indexName);
+        try {
+            searchOps.dropIndex();
+        } catch (Exception e) {
+            log.warn("Index did not exist prior to test setup: {}", e.getMessage());
+        }
+        final FTCreateParams params = FTCreateParams.createParams()
+                .on(IndexDataType.HASH)
+                .prefix(indexName + ":");
+        final List<SchemaField> fields = List.of( TextField.of("content"));
+        // When
+        final String result = searchOps.createIndex(params, fields);
+        // Then
+        assertThat(testListener.createIndexStartedCount.get()).isEqualTo(1);
+        assertThat(testListener.createIndexFinishedCount.get()).isEqualTo(1);
+        assertThat(testListener.lastCreateIndexName).isEqualTo(indexName);
+        assertThat(testListener.lastCreateParams).isEqualTo(params);
+        assertThat(testListener.lastCreateFields).isEqualTo(fields);
+        assertThat(testListener.lastCreateResult).isEqualTo(result);
+        return searchOps;
+    }
+}
diff --git a/tests/src/test/java/com/redis/om/spring/ops/TestCommandListener.java b/tests/src/test/java/com/redis/om/spring/ops/TestCommandListener.java
new file mode 100644
index 00000000..32666efb
--- /dev/null
+++ b/tests/src/test/java/com/redis/om/spring/ops/TestCommandListener.java
@@ -0,0 +1,284 @@
+package com.redis.om.spring.ops;
+
+import org.springframework.context.annotation.Primary;
+import org.springframework.stereotype.Component;
+import redis.clients.jedis.search.FTCreateParams;
+import redis.clients.jedis.search.FTSearchParams;
+import redis.clients.jedis.search.IndexOptions;
+import redis.clients.jedis.search.Query;
+import redis.clients.jedis.search.Schema;
+import redis.clients.jedis.search.SearchResult;
+import redis.clients.jedis.search.aggr.AggregationBuilder;
+import redis.clients.jedis.search.aggr.AggregationResult;
+import redis.clients.jedis.search.schemafields.SchemaField;
+
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+* Test implementation of CommandListener that tracks all invocations
+*/
+@Component
+@Primary
+class TestCommandListener implements CommandListener {
+    // Search tracking
+    AtomicInteger searchStartedCount = new AtomicInteger(0);
+    AtomicInteger searchFinishedCount = new AtomicInteger(0);
+    String lastSearchIndexName;
+    Query lastSearchQuery;
+    FTSearchParams lastSearchParams;
+    SearchResult lastSearchResult;
+
+    // Create index tracking
+    AtomicInteger createIndexStartedCount = new AtomicInteger(0);
+    AtomicInteger createIndexFinishedCount = new AtomicInteger(0);
+    String lastCreateIndexName;
+    FTCreateParams lastCreateParams;
+    List<SchemaField> lastCreateFields;
+    Schema lastCreateSchema;
+    IndexOptions lastCreateOptions;
+    String lastCreateResult;
+
+    // Aggregate tracking
+    AtomicInteger aggregateStartedCount = new AtomicInteger(0);
+    AtomicInteger aggregateFinishedCount = new AtomicInteger(0);
+    String lastAggregateIndexName;
+    AggregationBuilder lastAggregationBuilder;
+
+    // Drop index tracking
+    AtomicInteger dropIndexStartedCount = new AtomicInteger(0);
+    AtomicInteger dropIndexFinishedCount = new AtomicInteger(0);
+    AtomicInteger dropIndexAndDocumentsStartedCount = new AtomicInteger(0);
+    AtomicInteger dropIndexAndDocumentsFinishedCount = new AtomicInteger(0);
+    String lastDropIndexName;
+    String lastDropIndexResult;
+
+    // Info tracking
+    AtomicInteger infoStartedCount = new AtomicInteger(0);
+    AtomicInteger infoFinishedCount = new AtomicInteger(0);
+
+    // Alter index tracking
+    AtomicInteger alterIndexStartedCount = new AtomicInteger(0);
+    AtomicInteger alterIndexFinishedCount = new AtomicInteger(0);
+
+    // Set config tracking
+    AtomicInteger setConfigStartedCount = new AtomicInteger(0);
+    AtomicInteger setConfigFinishedCount = new AtomicInteger(0);
+
+    // Get config tracking
+    AtomicInteger getConfigStartedCount = new AtomicInteger(0);
+    AtomicInteger getConfigFinishedCount = new AtomicInteger(0);
+
+    // Get index config tracking
+    AtomicInteger getIndexConfigStartedCount = new AtomicInteger(0);
+    AtomicInteger getIndexConfigFinishedCount = new AtomicInteger(0);
+
+    // Add alias tracking
+    AtomicInteger addAliasStartedCount = new AtomicInteger(0);
+    AtomicInteger addAliasFinishedCount = new AtomicInteger(0);
+
+    // Update alias tracking
+    AtomicInteger updateAliasStartedCount = new AtomicInteger(0);
+    AtomicInteger updateAliasFinishedCount = new AtomicInteger(0);
+
+    // Delete alias tracking
+    AtomicInteger deleteAliasStartedCount = new AtomicInteger(0);
+    AtomicInteger deleteAliasFinishedCount = new AtomicInteger(0);
+
+    @Override
+    public void searchStarted(String indexName, Query q, FTSearchParams params) {
+      searchStartedCount.incrementAndGet();
+      lastSearchIndexName = indexName;
+      lastSearchQuery = q;
+      lastSearchParams = params;
+    }
+
+    @Override
+    public void searchFinished(String indexName, Query q, FTSearchParams params, SearchResult searchResult) {
+      searchFinishedCount.incrementAndGet();
+      lastSearchResult = searchResult;
+    }
+
+    @Override
+    public void createIndexStarted(String indexName, FTCreateParams params, List<SchemaField> fields,
+                                   Schema schema, IndexOptions options) {
+      createIndexStartedCount.incrementAndGet();
+      lastCreateIndexName = indexName;
+      lastCreateParams = params;
+      lastCreateFields = fields;
+      lastCreateSchema = schema;
+      lastCreateOptions = options;
+    }
+
+    @Override
+    public void createIndexFinished(String indexName, FTCreateParams params, List<SchemaField> fields,
+                                    Schema schema, IndexOptions options, String result) {
+      createIndexFinishedCount.incrementAndGet();
+      lastCreateResult = result;
+    }
+
+    @Override
+    public void aggregateStarted(String indexName, AggregationBuilder q) {
+      aggregateStartedCount.incrementAndGet();
+      lastAggregateIndexName = indexName;
+      lastAggregationBuilder = q;
+    }
+
+    @Override
+    public void aggregateFinished(final String indexName, final AggregationBuilder q, final AggregationResult aggregationResult) {
+      aggregateFinishedCount.incrementAndGet();
+    }
+
+    @Override
+    public void infoStarted(String indexName) {
+        infoStartedCount.incrementAndGet();
+    }
+
+    @Override
+    public void infoFinished(String indexName, Map<String, Object> info) {
+        infoFinishedCount.incrementAndGet();
+    }
+
+    @Override
+    public void dropIndexStarted(String indexName) {
+      dropIndexStartedCount.incrementAndGet();
+      lastDropIndexName = indexName;
+    }
+
+    @Override
+    public void dropIndexFinished(String indexName, String result) {
+      dropIndexFinishedCount.incrementAndGet();
+      lastDropIndexResult = result;
+    }
+
+    @Override
+    public void dropIndexAndDocumentsStarted(String string) {
+        dropIndexAndDocumentsStartedCount.incrementAndGet();
+    }
+
+    @Override
+    public void dropIndexAndDocumentsFinished(String string, String result) {
+        dropIndexAndDocumentsFinishedCount.incrementAndGet();
+        lastDropIndexResult = result;
+    }
+
+    @Override
+    public void alterIndexStarted(String string, SchemaField[] fields) {
+        alterIndexStartedCount.incrementAndGet();
+    }
+
+    @Override
+    public void alterIndexFinished(String string, SchemaField[] fields, String result) {
+        alterIndexFinishedCount.incrementAndGet();
+    }
+
+    @Override
+    public void setConfigStarted(String string, String option, String value) {
+        setConfigStartedCount.incrementAndGet();
+    }
+
+    @Override
+    public void setConfigFinished(String string, String option, String value, String result) {
+        setConfigFinishedCount.incrementAndGet();
+    }
+
+    @Override
+    public void getConfigStarted(String string, String option) {
+        getConfigStartedCount.incrementAndGet();
+    }
+
+    @Override
+    public void getConfigFinished(String string, String option, Map<String, Object> result) {
+        getConfigFinishedCount.incrementAndGet();
+    }
+
+    @Override
+    public void getIndexConfigStarted(String string, String option) {
+        getIndexConfigStartedCount.incrementAndGet();
+    }
+
+    @Override
+    public void getIndexConfigFinished(String string, String option, Map<String, Object> result) {
+        getIndexConfigFinishedCount.incrementAndGet();
+    }
+
+    @Override
+    public void addAliasStarted(String string, String name) {
+        addAliasStartedCount.incrementAndGet();
+    }
+
+    @Override
+    public void addAliasFinished(String string, String name, String result) {
+        addAliasFinishedCount.incrementAndGet();
+        lastDropIndexResult = result;
+    }
+
+    @Override
+    public void updateAliasStarted(String string, String name) {
+        updateAliasStartedCount.incrementAndGet();
+    }
+
+    @Override
+    public void updateAliasFinished(String string, String name, String result) {
+        updateAliasFinishedCount.incrementAndGet();
+        lastDropIndexResult = result;
+    }
+
+    @Override
+    public void deleteAliasStarted(String string, String name) {
+        deleteAliasStartedCount.incrementAndGet();
+    }
+
+    @Override
+    public void deleteAliasFinished(String string, String name, String result) {
+        deleteAliasFinishedCount.incrementAndGet();
+        lastDropIndexResult = result;
+    }
+
+    /**
+    * Reset all counters and tracked values
+    */
+    void reset() {
+        searchStartedCount.set(0);
+        searchFinishedCount.set(0);
+        createIndexStartedCount.set(0);
+        createIndexFinishedCount.set(0);
+        aggregateStartedCount.set(0);
+        aggregateFinishedCount.set(0);
+        dropIndexStartedCount.set(0);
+        dropIndexFinishedCount.set(0);
+        infoStartedCount.set(0);
+        infoFinishedCount.set(0);
+        alterIndexStartedCount.set(0);
+        alterIndexFinishedCount.set(0);
+        setConfigStartedCount.set(0);
+        setConfigFinishedCount.set(0);
+        getConfigStartedCount.set(0);
+        getConfigFinishedCount.set(0);
+        getIndexConfigStartedCount.set(0);
+        getIndexConfigFinishedCount.set(0);
+        alterIndexStartedCount.set(0);
+        alterIndexStartedCount.set(0);
+        addAliasStartedCount.set(0);
+        addAliasFinishedCount.set(0);
+        updateAliasStartedCount.set(0);
+        updateAliasFinishedCount.set(0);
+        deleteAliasStartedCount.set(0);
+        deleteAliasFinishedCount.set(0);
+        lastSearchIndexName = null;
+        lastSearchQuery = null;
+        lastSearchParams = null;
+        lastSearchResult = null;
+        lastCreateIndexName = null;
+        lastCreateParams = null;
+        lastCreateFields = null;
+        lastCreateSchema = null;
+        lastCreateOptions = null;
+        lastCreateResult = null;
+        lastAggregateIndexName = null;
+        lastAggregationBuilder = null;
+        lastDropIndexName = null;
+        lastDropIndexResult = null;
+    }
+  }
\ No newline at end of file