WIFI-1652 - implement performance counters for ovsdb, cassandra, and kafka

opensync-gateway/src/main/java/com/telecominfraproject/wlan/opensync/mqtt/OpensyncMqttClient.java

@@ -23,6 +23,15 @@ import com.google.protobuf.Descriptors;
 import com.google.protobuf.MessageOrBuilder;
 import com.google.protobuf.util.JsonFormat;
 import com.google.protobuf.util.JsonFormat.TypeRegistry;
+import com.netflix.servo.DefaultMonitorRegistry;
+import com.netflix.servo.monitor.BasicCounter;
+import com.netflix.servo.monitor.BasicTimer;
+import com.netflix.servo.monitor.Counter;
+import com.netflix.servo.monitor.MonitorConfig;
+import com.netflix.servo.monitor.Stopwatch;
+import com.netflix.servo.monitor.Timer;
+import com.netflix.servo.tag.TagList;
+import com.telecominfraproject.wlan.cloudmetrics.CloudMetricsTags;
 import com.telecominfraproject.wlan.opensync.external.integration.OpensyncExternalIntegrationInterface;
 import com.telecominfraproject.wlan.opensync.util.ZlibUtil;
 
@@ -43,9 +52,30 @@ public class OpensyncMqttClient implements ApplicationListener<ContextClosedEven
 
     public static Charset utf8 = Charset.forName("UTF-8");
 
+    private final TagList tags = CloudMetricsTags.commonTags;
+
+    private final Counter messagesReceived = new BasicCounter(
+            MonitorConfig.builder("osgw-mqtt-messagesReceived").withTags(tags).build());
+
+    private final Counter messageBytesReceived = new BasicCounter(
+            MonitorConfig.builder("osgw-mqtt-messageBytesReceived").withTags(tags).build());
+    
+    private final Timer timerMessageProcess = new BasicTimer(
+            MonitorConfig.builder("osgw-mqtt-messageProcessTimer").withTags(tags).build());
+
+
     @Autowired
     private OpensyncExternalIntegrationInterface extIntegrationInterface;
 
+    // dtop: use anonymous constructor to ensure that the following code always
+    // get executed,
+    // even when somebody adds another constructor in here
+    {
+        DefaultMonitorRegistry.getInstance().register(messagesReceived);
+        DefaultMonitorRegistry.getInstance().register(messageBytesReceived);
+        DefaultMonitorRegistry.getInstance().register(timerMessageProcess);
+    }
+
     //
     // See https://github.com/fusesource/mqtt-client for the docs
     //
@@ -180,6 +210,10 @@ public class OpensyncMqttClient implements ApplicationListener<ContextClosedEven
                             // queue
                             mqttMsg.ack();
 
+                            messagesReceived.increment();
+                            messageBytesReceived.increment(payload.length);
+                            Stopwatch stopwatchTimerMessageProcess = timerMessageProcess.start();
+                            
                             LOG.trace("received message on topic {} size {}", mqttMsg.getTopic(), payload.length);
 
                             if (payload[0] == 0x78) {
@@ -189,6 +223,7 @@ public class OpensyncMqttClient implements ApplicationListener<ContextClosedEven
                                 payload = ZlibUtil.decompress(payload);
                             }
 
+
                             // attempt to parse the message as protobuf
                             MessageOrBuilder encodedMsg = null;
                             try {
@@ -198,7 +233,6 @@ public class OpensyncMqttClient implements ApplicationListener<ContextClosedEven
                                 MQTT_LOG.info("topic = {} Report = {}", mqttMsg.getTopic(),
                                         jsonPrinter.print(encodedMsg));
 
-
                                 extIntegrationInterface.processMqttMessage(mqttMsg.getTopic(), (Report) encodedMsg);
 
                             } catch (Exception e) {
@@ -231,6 +265,8 @@ public class OpensyncMqttClient implements ApplicationListener<ContextClosedEven
                                         MQTT_LOG.info("topic = {} message = {}", mqttMsg.getTopic(), msgStr);
                                     }
                                 }
+                            } finally {
+                                stopwatchTimerMessageProcess.stop();
                             }
 
                         }

opensync-gateway/src/main/java/com/telecominfraproject/wlan/opensync/ovsdb/OvsdbListenerConfig.java

@@ -1,13 +1,24 @@
 package com.telecominfraproject.wlan.opensync.ovsdb;
 
-import java.util.concurrent.Executors;
+import java.util.concurrent.RejectedExecutionHandler;
 import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledThreadPoolExecutor;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.atomic.AtomicInteger;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 
+import com.netflix.servo.DefaultMonitorRegistry;
+import com.netflix.servo.monitor.BasicCounter;
+import com.netflix.servo.monitor.Counter;
+import com.netflix.servo.monitor.MonitorConfig;
+import com.netflix.servo.monitor.NumberGauge;
+import com.netflix.servo.tag.TagList;
+import com.telecominfraproject.wlan.cloudmetrics.CloudMetricsTags;
 import com.vmware.ovsdb.service.OvsdbPassiveConnectionListener;
 import com.vmware.ovsdb.service.impl.OvsdbPassiveConnectionListenerImpl;
 
@@ -16,12 +27,68 @@ public class OvsdbListenerConfig {
 
     private static final Logger LOG = LoggerFactory.getLogger(OvsdbListenerConfig.class);
 
+    private final TagList tags = CloudMetricsTags.commonTags;
+
+    final Counter rejectedTasks = new BasicCounter(MonitorConfig.builder("osgw-ovsdb-rejectedTasks").withTags(tags).build());
+    final Counter submittedTasks = new BasicCounter(MonitorConfig.builder("osgw-ovsdb-submittedTasks").withTags(tags).build());
+    final Counter completedTasks = new BasicCounter(MonitorConfig.builder("osgw-ovsdb-completedTasks").withTags(tags).build());
+    
+    private AtomicInteger tasksInFlight = new AtomicInteger(0);
+    
+    private final NumberGauge tasksInFlightGauge = new NumberGauge(
+            MonitorConfig.builder("osgw-ovsdb-tasksInFlight").withTags(tags).build(), tasksInFlight);
+
+    // dtop: use anonymous constructor to ensure that the following code always
+    // get executed,
+    // even when somebody adds another constructor in here
+    {
+        DefaultMonitorRegistry.getInstance().register(rejectedTasks);
+        DefaultMonitorRegistry.getInstance().register(submittedTasks);
+        DefaultMonitorRegistry.getInstance().register(completedTasks);
+        DefaultMonitorRegistry.getInstance().register(tasksInFlightGauge);
+    }
+
     @Bean
     public OvsdbPassiveConnectionListener ovsdbPassiveConnectionListener(
             @org.springframework.beans.factory.annotation.Value("${tip.wlan.ovsdb.listener.threadPoolSize:10}")
             int threadPoolSize) {
         LOG.debug("Configuring OvsdbPassiveConnectionListener with thread pool size {}", threadPoolSize);
-        ScheduledExecutorService executorService = Executors.newScheduledThreadPool(threadPoolSize);    
+        
+        ThreadFactory threadFactory = new ThreadFactory() {
+            private AtomicInteger thrNum = new AtomicInteger();
+            
+            @Override
+            public Thread newThread(Runnable r) {
+                Thread thr = new Thread(r, "ovsdb-exec-pool-" + thrNum.incrementAndGet());
+                thr.setDaemon(true);
+                return thr;
+            }
+        };
+        
+        RejectedExecutionHandler rejectedExecHandler = new ThreadPoolExecutor.AbortPolicy() {
+            @Override
+            public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
+                rejectedTasks.increment();
+                super.rejectedExecution(r, executor);
+            }
+        };
+        
+        ScheduledExecutorService executorService = new ScheduledThreadPoolExecutor(threadPoolSize, threadFactory, rejectedExecHandler) {
+            @Override
+            protected void beforeExecute(Thread t, Runnable r) {
+                submittedTasks.increment();
+                tasksInFlight.incrementAndGet();
+                super.beforeExecute(t, r);
+            }
+            
+            @Override
+            protected void afterExecute(Runnable r, Throwable t) {
+                completedTasks.increment();
+                tasksInFlight.decrementAndGet();
+                super.afterExecute(r, t);
+            }
+        };
+        
         OvsdbPassiveConnectionListener listener = new OvsdbPassiveConnectionListenerImpl(executorService);
         return listener;
     }    

opensync-gateway/src/main/java/com/telecominfraproject/wlan/opensync/ovsdb/OvsdbSessionMap.java

@@ -1,14 +1,21 @@
 package com.telecominfraproject.wlan.opensync.ovsdb;
 
 import java.util.HashSet;
-import java.util.Set;
 import java.util.Map.Entry;
+import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicInteger;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.stereotype.Component;
 
+import com.netflix.servo.DefaultMonitorRegistry;
+import com.netflix.servo.monitor.MonitorConfig;
+import com.netflix.servo.monitor.Monitors;
+import com.netflix.servo.monitor.NumberGauge;
+import com.netflix.servo.tag.TagList;
+import com.telecominfraproject.wlan.cloudmetrics.CloudMetricsTags;
 import com.telecominfraproject.wlan.opensync.external.integration.OvsdbSession;
 import com.telecominfraproject.wlan.opensync.external.integration.OvsdbSessionMapInterface;
 import com.vmware.ovsdb.service.OvsdbClient;
@@ -17,9 +24,23 @@ import com.vmware.ovsdb.service.OvsdbClient;
 public class OvsdbSessionMap implements OvsdbSessionMapInterface {
 
     private static final Logger LOG = LoggerFactory.getLogger(OvsdbSessionMap.class);
+
+    private final TagList tags = CloudMetricsTags.commonTags;
+    
+    private AtomicInteger totalEquipmentConnections = new AtomicInteger(0);
+        
+    private final NumberGauge totalEquipmentConnectionsGauge = new NumberGauge(
+            MonitorConfig.builder("osgw-totalEquipmentConnections").withTags(tags).build(), totalEquipmentConnections);
     
     private final ConcurrentHashMap<String, OvsdbSession> connectedClients = new ConcurrentHashMap<>();
 
+    // dtop: use anonymous constructor to ensure that the following code always
+    // get executed,
+    // even when somebody adds another constructor in here
+    {
+        DefaultMonitorRegistry.getInstance().register(totalEquipmentConnectionsGauge);
+    }
+
     @Override
     public OvsdbSession getSession(String apId) {
         LOG.info("Get session for AP {}", apId);
@@ -29,7 +50,11 @@ public class OvsdbSessionMap implements OvsdbSessionMapInterface {
     @Override
     public OvsdbSession removeSession(String apId) { 
         LOG.info("Removing session for AP {}", apId);
-        return connectedClients.remove(apId);
+        OvsdbSession ret = connectedClients.remove(apId);
+        if(ret!=null) {
+            totalEquipmentConnections.decrementAndGet();
+        }
+        return ret;
     }
 
     @Override
@@ -37,7 +62,7 @@ public class OvsdbSessionMap implements OvsdbSessionMapInterface {
         try {
             LOG.info("Close session for AP {}", apId);
             connectedClients.get(apId).getOvsdbClient().shutdown();
-            connectedClients.remove(apId);
+            removeSession(apId);
             LOG.info("Closed ovsdb session for {}", apId);
         }catch (Exception e) {
             // do nothing
@@ -58,6 +83,8 @@ public class OvsdbSessionMap implements OvsdbSessionMapInterface {
             }catch (Exception e) {
                 // do nothing
             }            
+        } else {
+            totalEquipmentConnections.incrementAndGet();
         }
         
         LOG.info("Created new ovsdb session for {}", apId);

opensync-gateway/src/main/java/com/telecominfraproject/wlan/opensync/ovsdb/TipWlanOvsdbClient.java

@@ -1,6 +1,13 @@
 package com.telecominfraproject.wlan.opensync.ovsdb;
 
 import com.google.common.collect.ImmutableMap;
+import com.netflix.servo.DefaultMonitorRegistry;
+import com.netflix.servo.monitor.BasicCounter;
+import com.netflix.servo.monitor.Counter;
+import com.netflix.servo.monitor.MonitorConfig;
+import com.netflix.servo.monitor.Monitors;
+import com.netflix.servo.tag.TagList;
+import com.telecominfraproject.wlan.cloudmetrics.CloudMetricsTags;
 import com.telecominfraproject.wlan.core.model.equipment.MacAddress;
 import com.telecominfraproject.wlan.core.model.equipment.RadioType;
 import com.telecominfraproject.wlan.opensync.external.integration.OpensyncExternalIntegrationInterface;
@@ -10,6 +17,8 @@ import com.telecominfraproject.wlan.opensync.external.integration.OvsdbSession;
 import com.telecominfraproject.wlan.opensync.external.integration.OvsdbSessionMapInterface;
 import com.telecominfraproject.wlan.opensync.external.integration.models.*;
 import com.telecominfraproject.wlan.opensync.ovsdb.dao.OvsdbDao;
+import com.telecominfraproject.wlan.opensync.ovsdb.metrics.OvsdbClientWithMetrics;
+import com.telecominfraproject.wlan.opensync.ovsdb.metrics.OvsdbMetrics;
 import com.telecominfraproject.wlan.opensync.util.OvsdbStringConstants;
 import com.telecominfraproject.wlan.opensync.util.SslUtil;
 import com.vmware.ovsdb.callback.ConnectionCallback;
@@ -36,6 +45,21 @@ public class TipWlanOvsdbClient implements OvsdbClientInterface {
 
     private static final Logger LOG = LoggerFactory.getLogger(TipWlanOvsdbClient.class);
 
+    private final TagList tags = CloudMetricsTags.commonTags;
+
+    private final Counter connectionsAttempted = new BasicCounter(
+            MonitorConfig.builder("osgw-connectionsAttempted").withTags(tags).build());
+
+    private final Counter connectionsFailed = new BasicCounter(
+            MonitorConfig.builder("osgw-connectionsFailed").withTags(tags).build());
+
+    private final Counter connectionsCreated = new BasicCounter(
+            MonitorConfig.builder("osgw-connectionsCreated").withTags(tags).build());
+
+    private final Counter connectionsDropped = new BasicCounter(
+            MonitorConfig.builder("osgw-connectionsDropped").withTags(tags).build());
+    
+
     @org.springframework.beans.factory.annotation.Value("${tip.wlan.ovsdb.listenPort:6640}")
     private int ovsdbListenPort;
 
@@ -63,9 +87,22 @@ public class TipWlanOvsdbClient implements OvsdbClientInterface {
     @Autowired
     private OvsdbSessionMapInterface ovsdbSessionMapInterface;
 
+    @Autowired
+    private OvsdbMetrics ovsdbMetrics;
+
     @org.springframework.beans.factory.annotation.Value("${tip.wlan.manager.collectionIntervalSec.event:60}")
     private long collectionIntervalSecEvent;
 
+    // dtop: use anonymous constructor to ensure that the following code always
+    // get executed,
+    // even when somebody adds another constructor in here
+    {
+        DefaultMonitorRegistry.getInstance().register(connectionsAttempted);
+        DefaultMonitorRegistry.getInstance().register(connectionsCreated);
+        DefaultMonitorRegistry.getInstance().register(connectionsDropped);
+        DefaultMonitorRegistry.getInstance().register(connectionsFailed);
+    }
+
     @PostConstruct
     private void postCreate() {
         listenForConnections();
@@ -78,6 +115,12 @@ public class TipWlanOvsdbClient implements OvsdbClientInterface {
             @Override
             public void connected(OvsdbClient ovsdbClient) {
 
+                connectionsAttempted.increment();
+                
+                if(! (ovsdbClient instanceof OvsdbClientWithMetrics )) {
+                    ovsdbClient = new OvsdbClientWithMetrics(ovsdbClient, ovsdbMetrics);
+                }
+                
                 String remoteHost = ovsdbClient.getConnectionInfo().getRemoteAddress().getHostAddress();
                 int localPort = ovsdbClient.getConnectionInfo().getLocalPort();
                 String subjectDn;
@@ -102,14 +145,17 @@ public class TipWlanOvsdbClient implements OvsdbClientInterface {
 
                     monitorOvsdbStateTables(ovsdbClient, key);
 
+                    connectionsCreated.increment();
                     LOG.info("ovsdbClient connected from {} on port {} AP {} ", remoteHost, localPort, key);
                     LOG.info("ovsdbClient connectedClients = {}", ovsdbSessionMapInterface.getNumSessions());
 
                 } catch (IllegalStateException e) {
+                    connectionsFailed.increment();
                     LOG.error("autoprovisioning error {}", e.getMessage(), e);
                     // something is wrong with the SSL
                     ovsdbClient.shutdown();
                 } catch (Exception e) {
+                    connectionsFailed.increment();
                     LOG.error("ovsdbClient error", e);
                     // something is wrong with the SSL
                     ovsdbClient.shutdown();
@@ -120,6 +166,8 @@ public class TipWlanOvsdbClient implements OvsdbClientInterface {
             @Override
             public void disconnected(OvsdbClient ovsdbClient) {
 
+                connectionsDropped.increment();
+                
                 String remoteHost;
                 int localPort;
                 String clientCn;

opensync-gateway/src/main/java/com/telecominfraproject/wlan/opensync/ovsdb/TipWlanOvsdbRedirector.java

@@ -10,6 +10,13 @@ import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.context.annotation.Profile;
 import org.springframework.stereotype.Component;
 
+import com.netflix.servo.DefaultMonitorRegistry;
+import com.netflix.servo.monitor.BasicCounter;
+import com.netflix.servo.monitor.Counter;
+import com.netflix.servo.monitor.MonitorConfig;
+import com.netflix.servo.monitor.Monitors;
+import com.netflix.servo.tag.TagList;
+import com.telecominfraproject.wlan.cloudmetrics.CloudMetricsTags;
 import com.telecominfraproject.wlan.opensync.ovsdb.dao.OvsdbDao;
 import com.telecominfraproject.wlan.opensync.util.SslUtil;
 import com.vmware.ovsdb.callback.ConnectionCallback;
@@ -24,6 +31,20 @@ public class TipWlanOvsdbRedirector {
 
     private static final Logger LOG = LoggerFactory.getLogger(TipWlanOvsdbRedirector.class);
     
+    private final TagList tags = CloudMetricsTags.commonTags;
+
+    private final Counter connectionsAttempted = new BasicCounter(
+            MonitorConfig.builder("osgw-redirector-connectionsAttempted").withTags(tags).build());
+
+    private final Counter connectionsFailed = new BasicCounter(
+            MonitorConfig.builder("osgw-redirector-connectionsFailed").withTags(tags).build());
+
+    private final Counter connectionsCreated = new BasicCounter(
+            MonitorConfig.builder("osgw-redirector-connectionsCreated").withTags(tags).build());
+
+    private final Counter connectionsDropped = new BasicCounter(
+            MonitorConfig.builder("osgw-redirector-connectionsDropped").withTags(tags).build());
+
     @org.springframework.beans.factory.annotation.Value("${tip.wlan.ovsdb.redirector.listenPort:6643}")
     private int ovsdbRedirectorListenPort;
 
@@ -41,10 +62,21 @@ public class TipWlanOvsdbRedirector {
         listenForConnections();
     }
     
+    // dtop: use anonymous constructor to ensure that the following code always
+    // get executed,
+    // even when somebody adds another constructor in here
+    {
+        DefaultMonitorRegistry.getInstance().register(connectionsAttempted);
+        DefaultMonitorRegistry.getInstance().register(connectionsCreated);
+        DefaultMonitorRegistry.getInstance().register(connectionsDropped);
+        DefaultMonitorRegistry.getInstance().register(connectionsFailed);
+    }
+
     public void listenForConnections() {
 
         ConnectionCallback connectionCallback = new ConnectionCallback() {
             public void connected(OvsdbClient ovsdbClient) {
+                connectionsAttempted.increment();
                 String remoteHost = ovsdbClient.getConnectionInfo().getRemoteAddress().getHostAddress();
                 int localPort = ovsdbClient.getConnectionInfo().getLocalPort();
                 String subjectDn = null;
@@ -54,8 +86,9 @@ public class TipWlanOvsdbRedirector {
                     String clientCn = SslUtil.extractCN(subjectDn);
                     LOG.info("ovsdbClient redirector connected from {} on port {} clientCn {}", remoteHost, localPort, clientCn);                
                     ovsdbDao.performRedirect(ovsdbClient, clientCn);
-
+                    connectionsCreated.increment();
                 } catch (Exception e) {
+                    connectionsFailed.increment();
                     //something is wrong with the SSL or with the redirect
                     ovsdbClient.shutdown();
                     return;
@@ -63,6 +96,7 @@ public class TipWlanOvsdbRedirector {
             }
             
             public void disconnected(OvsdbClient ovsdbClient) {
+                connectionsDropped.increment();
                 String remoteHost = ovsdbClient.getConnectionInfo().getRemoteAddress().getHostAddress();
                 int localPort = ovsdbClient.getConnectionInfo().getLocalPort();
                 String subjectDn = null;

opensync-gateway/src/main/java/com/telecominfraproject/wlan/opensync/ovsdb/metrics/OvsdbClientWithMetrics.java

@@ -0,0 +1,78 @@
+package com.telecominfraproject.wlan.opensync.ovsdb.metrics;
+
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+
+import com.vmware.ovsdb.callback.LockCallback;
+import com.vmware.ovsdb.callback.MonitorCallback;
+import com.vmware.ovsdb.exception.OvsdbClientException;
+import com.vmware.ovsdb.protocol.methods.LockResult;
+import com.vmware.ovsdb.protocol.methods.MonitorRequests;
+import com.vmware.ovsdb.protocol.methods.TableUpdates;
+import com.vmware.ovsdb.protocol.operation.Operation;
+import com.vmware.ovsdb.protocol.operation.result.OperationResult;
+import com.vmware.ovsdb.protocol.schema.DatabaseSchema;
+import com.vmware.ovsdb.service.OvsdbClient;
+import com.vmware.ovsdb.service.OvsdbConnectionInfo;
+
+public class OvsdbClientWithMetrics implements OvsdbClient {
+    
+    private final OvsdbMetrics metrics; 
+    private final OvsdbClient delegate;
+
+    public OvsdbClientWithMetrics(OvsdbClient delegate, OvsdbMetrics metrics) {
+        this.delegate = delegate;
+        this.metrics = metrics;
+    }
+
+    public CompletableFuture<String[]> listDatabases() throws OvsdbClientException {
+        metrics.listDatabases.increment();
+        return delegate.listDatabases();
+    }
+
+    public CompletableFuture<DatabaseSchema> getSchema(String dbName) throws OvsdbClientException {
+        metrics.getSchema.increment();
+        return delegate.getSchema(dbName);
+    }
+
+    public CompletableFuture<OperationResult[]> transact(String dbName, List<Operation> operations)
+            throws OvsdbClientException {
+        metrics.transact.increment();
+        return delegate.transact(dbName, operations);
+    }
+
+    public CompletableFuture<TableUpdates> monitor(String dbName, String monitorId, MonitorRequests monitorRequests,
+            MonitorCallback monitorCallback) throws OvsdbClientException {
+        metrics.monitor.increment();        
+        return delegate.monitor(dbName, monitorId, monitorRequests, monitorCallback);
+    }
+
+    public CompletableFuture<Void> cancelMonitor(String monitorId) throws OvsdbClientException {
+        metrics.cancelMonitor.increment();        
+        return delegate.cancelMonitor(monitorId);
+    }
+
+    public CompletableFuture<LockResult> lock(String lockId, LockCallback lockCallback) throws OvsdbClientException {
+        metrics.lock.increment();        
+        return delegate.lock(lockId, lockCallback);
+    }
+
+    public CompletableFuture<LockResult> steal(String lockId, LockCallback lockCallback) throws OvsdbClientException {
+        metrics.steal.increment();        
+        return delegate.steal(lockId, lockCallback);
+    }
+
+    public CompletableFuture<Void> unlock(String lockId) throws OvsdbClientException {
+        metrics.unlock.increment();        
+        return delegate.unlock(lockId);
+    }
+
+    public OvsdbConnectionInfo getConnectionInfo() {
+        return delegate.getConnectionInfo();
+    }
+
+    public void shutdown() {
+        delegate.shutdown();
+    }    
+
+}

opensync-gateway/src/main/java/com/telecominfraproject/wlan/opensync/ovsdb/metrics/OvsdbMetrics.java

@@ -0,0 +1,40 @@
+package com.telecominfraproject.wlan.opensync.ovsdb.metrics;
+
+import org.springframework.stereotype.Component;
+
+import com.netflix.servo.DefaultMonitorRegistry;
+import com.netflix.servo.monitor.BasicCounter;
+import com.netflix.servo.monitor.Counter;
+import com.netflix.servo.monitor.MonitorConfig;
+import com.netflix.servo.tag.TagList;
+import com.telecominfraproject.wlan.cloudmetrics.CloudMetricsTags;
+
+@Component
+public class OvsdbMetrics {
+    
+    private final TagList tags = CloudMetricsTags.commonTags;
+
+    final Counter listDatabases = new BasicCounter(MonitorConfig.builder("osgw-ovsdb-listDatabases").withTags(tags).build());
+    final Counter getSchema = new BasicCounter(MonitorConfig.builder("osgw-ovsdb-getSchema").withTags(tags).build());
+    final Counter transact = new BasicCounter(MonitorConfig.builder("osgw-ovsdb-transact").withTags(tags).build());
+    final Counter monitor = new BasicCounter(MonitorConfig.builder("osgw-ovsdb-monitor").withTags(tags).build());
+    final Counter cancelMonitor = new BasicCounter(MonitorConfig.builder("osgw-ovsdb-cancelMonitor").withTags(tags).build());
+    final Counter lock = new BasicCounter(MonitorConfig.builder("osgw-ovsdb-lock").withTags(tags).build());
+    final Counter steal = new BasicCounter(MonitorConfig.builder("osgw-ovsdb-steal").withTags(tags).build());
+    final Counter unlock = new BasicCounter(MonitorConfig.builder("osgw-ovsdb-unlock").withTags(tags).build());
+
+    // dtop: use anonymous constructor to ensure that the following code always
+    // get executed,
+    // even when somebody adds another constructor in here
+    {
+        DefaultMonitorRegistry.getInstance().register(listDatabases);
+        DefaultMonitorRegistry.getInstance().register(getSchema);
+        DefaultMonitorRegistry.getInstance().register(transact);
+        DefaultMonitorRegistry.getInstance().register(monitor);
+        DefaultMonitorRegistry.getInstance().register(cancelMonitor);
+        DefaultMonitorRegistry.getInstance().register(lock);
+        DefaultMonitorRegistry.getInstance().register(steal);
+        DefaultMonitorRegistry.getInstance().register(unlock);
+    }
+
+}

opensync-gateway/src/test/java/com/telecominfraproject/wlan/opensync/ovsdb/OpensyncGatewayTipWlanOvsdbClientTest.java

@@ -30,6 +30,7 @@ import com.telecominfraproject.wlan.opensync.external.integration.OvsdbSession;
 import com.telecominfraproject.wlan.opensync.external.integration.OvsdbSessionMapInterface;
 import com.telecominfraproject.wlan.opensync.external.integration.models.OpensyncAPConfig;
 import com.telecominfraproject.wlan.opensync.ovsdb.dao.OvsdbDao;
+import com.telecominfraproject.wlan.opensync.ovsdb.metrics.OvsdbMetrics;
 import com.telecominfraproject.wlan.profile.network.models.ApNetworkConfiguration;
 import com.vmware.ovsdb.callback.MonitorCallback;
 import com.vmware.ovsdb.exception.OvsdbClientException;
@@ -47,7 +48,7 @@ import io.netty.handler.ssl.SslContext;
 @SpringBootTest(webEnvironment = WebEnvironment.NONE, classes = OpensyncGatewayTipWlanOvsdbClientTest.class)
 @Import(value = { OpensyncGatewayTipWlanOvsdbClientTest.Config.class, TipWlanOvsdbClient.class,
         TipWlanOvsdbRedirector.class, OvsdbListenerConfig.class, OvsdbSessionMapInterface.class, OvsdbDao.class,
-        OpensyncExternalIntegrationInterface.class, OvsdbSession.class, SslContext.class })
+        OpensyncExternalIntegrationInterface.class, OvsdbSession.class, OvsdbMetrics.class, SslContext.class })
 public class OpensyncGatewayTipWlanOvsdbClientTest {
 
     @MockBean