MXS-1220: Implement JSON diagnostics for most routers

All routers except the binlogrouter now fully implement the JSON
diagnostic entry point. The binlogrouter needs to be handled in a separate
commit as it produces a large amount of diagnostic output.

examples/roundrobinrouter.cpp

@@ -572,7 +572,7 @@ static MXS_ROUTER_SESSION* newSession(MXS_ROUTER* instance, MXS_SESSION* session
 static void closeSession(MXS_ROUTER* instance, MXS_ROUTER_SESSION* session);
 static void freeSession(MXS_ROUTER* instance, MXS_ROUTER_SESSION* session);
 static int routeQuery(MXS_ROUTER* instance, MXS_ROUTER_SESSION* session, GWBUF* querybuf);
-static void diagnostics(MXS_ROUTER* instance, DCB* dcb);
+static json_t* diagnostics(MXS_ROUTER* instance);
 static void clientReply(MXS_ROUTER* instance, MXS_ROUTER_SESSION* router_session,
                         GWBUF* resultbuf, DCB* backend_dcb);
 static void handleError(MXS_ROUTER* instance, MXS_ROUTER_SESSION* router_session,
@@ -759,12 +759,16 @@ static int routeQuery(MXS_ROUTER* instance, MXS_ROUTER_SESSION* session, GWBUF*
  * @param   instance    The router instance
  * @param   dcb         The DCB for diagnostic output
  */
-static void diagnostics(MXS_ROUTER* instance, DCB* dcb)
+static json_t* diagnostics(MXS_ROUTER* instance)
 {
     RRRouter* router = static_cast<RRRouter*>(instance);
-    dcb_printf(dcb, "\t\tQueries routed successfully: %lu\n", router->m_routing_s);
+    json_t* rval = json_object();
-    dcb_printf(dcb, "\t\tFailed routing attempts:     %lu\n", router->m_routing_f);
+
-    dcb_printf(dcb, "\t\tClient replies routed:       %lu\n", router->m_routing_c);
+    json_object_set_new(rval, "queries_ok", json_integer(router->m_routing_s));
+    json_object_set_new(rval, "queries_failed", json_integer(router->m_routing_f));
+    json_object_set_new(rval, "replies", json_integer(router->m_routing_c));
+
+    return rval;
 }
 
 /**

examples/testfilter.c

@@ -29,20 +29,16 @@
  * @endverbatim
  */
 
-
+static MXS_FILTER *createInstance(const char *name, char **options, MXS_CONFIG_PARAMETER *params);
-static  MXS_FILTER  *createInstance(const char *name, char **options, MXS_CONFIG_PARAMETER *params);
+static MXS_FILTER_SESSION *newSession(MXS_FILTER *instance, MXS_SESSION *session);
-static  MXS_FILTER_SESSION *newSession(MXS_FILTER *instance, MXS_SESSION *session);
+static void closeSession(MXS_FILTER *instance, MXS_FILTER_SESSION *session);
-static  void    closeSession(MXS_FILTER *instance, MXS_FILTER_SESSION *session);
+static void freeSession(MXS_FILTER *instance, MXS_FILTER_SESSION *session);
-static  void    freeSession(MXS_FILTER *instance, MXS_FILTER_SESSION *session);
+static void setDownstream(MXS_FILTER *instance, MXS_FILTER_SESSION *fsession, MXS_DOWNSTREAM *downstream);
-static  void    setDownstream(MXS_FILTER *instance, MXS_FILTER_SESSION *fsession, MXS_DOWNSTREAM *downstream);
+static int routeQuery(MXS_FILTER *instance, MXS_FILTER_SESSION *fsession, GWBUF *queue);
-static  int routeQuery(MXS_FILTER *instance, MXS_FILTER_SESSION *fsession, GWBUF *queue);
+static json_t* diagnostic(MXS_FILTER *instance, MXS_FILTER_SESSION *fsession);
-static  void    diagnostic(MXS_FILTER *instance, MXS_FILTER_SESSION *fsession, DCB *dcb);
 static uint64_t getCapabilities(MXS_FILTER* instance);
 static void destroyInstance(MXS_FILTER *instance);
 
-
-
-
 /**
  * A dummy instance structure
  */
@@ -225,18 +221,9 @@ routeQuery(MXS_FILTER *instance, MXS_FILTER_SESSION *session, GWBUF *queue)
  * @param   fsession    Filter session, may be NULL
  * @param   dcb     The DCB for diagnostic output
  */
-static  void
+static json_t* diagnostic(MXS_FILTER *instance, MXS_FILTER_SESSION *fsession)
-diagnostic(MXS_FILTER *instance, MXS_FILTER_SESSION *fsession, DCB *dcb)
 {
-    TEST_INSTANCE   *my_instance = (TEST_INSTANCE *)instance;
+    return NULL;
-    TEST_SESSION    *my_session = (TEST_SESSION *)fsession;
-
-    if (my_session)
-        dcb_printf(dcb, "\t\tNo. of queries routed by filter: %d\n",
-                   my_session->count);
-    else
-        dcb_printf(dcb, "\t\tNo. of sessions created: %d\n",
-                   my_instance->sessions);
 }
 
 /**

examples/testroute.c

@@ -21,7 +21,7 @@ static void closeSession(MXS_ROUTER *instance, MXS_ROUTER_SESSION *session);
 static void freeSession(MXS_ROUTER *instance, MXS_ROUTER_SESSION *session);
 static int routeQuery(MXS_ROUTER *instance, MXS_ROUTER_SESSION *session, GWBUF *queue);
 static void clientReply(MXS_ROUTER *instance, MXS_ROUTER_SESSION *session, GWBUF *queue, DCB*);
-static void diagnostic(MXS_ROUTER *instance, DCB *dcb);
+static json_t* diagnostic(MXS_ROUTER *instance);
 static uint64_t getCapabilities(MXS_ROUTER* instance);
 static void handleError(MXS_ROUTER *instance,
                         MXS_ROUTER_SESSION *router_session,
@@ -145,9 +145,9 @@ void clientReply(MXS_ROUTER* instance, MXS_ROUTER_SESSION* session, GWBUF* queue
  * @param   instance    The router instance
  * @param   dcb     The DCB for diagnostic output
  */
-static  void
+static json_t* diagnostic(MXS_ROUTER *instance)
-diagnostic(MXS_ROUTER *instance, DCB *dcb)
 {
+    return NULL;
 }
 
 static uint64_t getCapabilities(MXS_ROUTER* instance)

include/maxscale/router.hh

@@ -173,11 +173,15 @@ public:
         return rv;
     }
 
-    static void diagnostics(MXS_ROUTER* pInstance, DCB* pDcb)
+    static json_t* diagnostics(MXS_ROUTER* pInstance)
     {
         RouterType* pRouter = static_cast<RouterType*>(pInstance);
 
-        MXS_EXCEPTION_GUARD(pRouter->diagnostics(pDcb));
+        json_t* rval = NULL;
+
+        MXS_EXCEPTION_GUARD(rval = pRouter->diagnostics());
+
+        return rval;
     }
 
     static void clientReply(MXS_ROUTER*, MXS_ROUTER_SESSION* pData, GWBUF* pPacket, DCB* pBackend)

server/modules/routing/binlogrouter/blr.c

@@ -95,7 +95,7 @@ static  MXS_ROUTER_SESSION *newSession(MXS_ROUTER *instance, MXS_SESSION *sessio
 static  void closeSession(MXS_ROUTER *instance, MXS_ROUTER_SESSION *router_session);
 static  void freeSession(MXS_ROUTER *instance, MXS_ROUTER_SESSION *router_session);
 static  int routeQuery(MXS_ROUTER *instance, MXS_ROUTER_SESSION *router_session, GWBUF *queue);
-static  void diagnostics(MXS_ROUTER *instance, DCB *dcb);
+static  json_t* diagnostics(MXS_ROUTER *instance);
 static  void clientReply(MXS_ROUTER *instance,
                          MXS_ROUTER_SESSION *router_session,
                          GWBUF *queue,
@@ -1287,9 +1287,12 @@ spin_reporter(void *dcb, char *desc, int value)
  * @param instance  Instance of the router
  * @param dcb       DCB to send diagnostics to
  */
-static void
+static json_t* diagnostics(MXS_ROUTER *router)
-diagnostics(MXS_ROUTER *router, DCB *dcb)
 {
+    // TODO: Fix this
+    return NULL;
+
+    DCB *dcb = NULL;
     ROUTER_INSTANCE *router_inst = (ROUTER_INSTANCE *)router;
     ROUTER_SLAVE *session;
     int i = 0, j;

server/modules/routing/cli/cli.c

@@ -48,7 +48,7 @@ static  MXS_ROUTER_SESSION *newSession(MXS_ROUTER *instance, MXS_SESSION *sessio
 static  void closeSession(MXS_ROUTER *instance, MXS_ROUTER_SESSION *router_session);
 static  void freeSession(MXS_ROUTER *instance, MXS_ROUTER_SESSION *router_session);
 static  int execute(MXS_ROUTER *instance, MXS_ROUTER_SESSION *router_session, GWBUF *queue);
-static  void diagnostics(MXS_ROUTER *instance, DCB *dcb);
+static  json_t* diagnostics(MXS_ROUTER *instance);
 static  uint64_t getCapabilities(MXS_ROUTER* instance);
 
 extern int execute_cmd(CLI_SESSION *cli);
@@ -284,10 +284,9 @@ execute(MXS_ROUTER *instance, MXS_ROUTER_SESSION *router_session, GWBUF *queue)
  * @param instance  Instance of the router
  * @param dcb       DCB to send diagnostics to
  */
-static  void
+static  json_t* diagnostics(MXS_ROUTER *instance)
-diagnostics(MXS_ROUTER *instance, DCB *dcb)
 {
-    return; /* Nothing to do currently */
+    return NULL;
 }
 
 static uint64_t getCapabilities(MXS_ROUTER *instance)

server/modules/routing/debugcli/debugcli.c

@@ -47,7 +47,7 @@ static  MXS_ROUTER_SESSION *newSession(MXS_ROUTER *instance, MXS_SESSION *sessio
 static  void closeSession(MXS_ROUTER *instance, MXS_ROUTER_SESSION *router_session);
 static  void freeSession(MXS_ROUTER *instance, MXS_ROUTER_SESSION *router_session);
 static  int execute(MXS_ROUTER *instance, MXS_ROUTER_SESSION *router_session, GWBUF *queue);
-static  void diagnostics(MXS_ROUTER *instance, DCB *dcb);
+static  json_t* diagnostics(MXS_ROUTER *instance);
 static  uint64_t getCapabilities(MXS_ROUTER* instance);
 
 extern int execute_cmd(CLI_SESSION *cli);
@@ -287,10 +287,9 @@ execute(MXS_ROUTER *instance, MXS_ROUTER_SESSION *router_session, GWBUF *queue)
  * @param instance  Instance of the router
  * @param dcb       DCB to send diagnostics to
  */
-static  void
+static  json_t* diagnostics(MXS_ROUTER *instance)
-diagnostics(MXS_ROUTER *instance, DCB *dcb)
 {
-    return; /* Nothing to do currently */
+    return NULL;
 }
 
 static uint64_t getCapabilities(MXS_ROUTER* instance)

server/modules/routing/hintrouter/hintrouter.cc

@@ -144,23 +144,31 @@ HintRouterSession* HintRouter::newSession(MXS_SESSION *pSession)
     return rval;
 }
 
-void HintRouter::diagnostics(DCB* pOut)
+json_t* HintRouter::diagnostics()
 {
     HR_ENTRY();
+
+    json_t* rval = json_object();
+    json_t* arr = json_array();
+
     for (int i = 0; default_action_values[i].name; i++)
     {
         if (default_action_values[i].enum_value == (uint64_t)m_default_action)
         {
-            dcb_printf(pOut, "\tDefault action: route to %s\n", default_action_values[i].name);
+            json_array_append(arr, json_string(default_action_values[i].name));
         }
     }
-    dcb_printf(pOut, "\tDefault server: %s\n", m_default_server.c_str());
+
-    dcb_printf(pOut, "\tMaximum slave connections/session: %d\n", m_max_slaves);
+    json_object_set_new(rval, "default_action", arr);
-    dcb_printf(pOut, "\tTotal cumulative slave connections: %d\n", m_total_slave_conns);
+    json_object_set_new(rval, "default_server", json_string(m_default_server.c_str()));
-    dcb_printf(pOut, "\tQueries routed to master: %d\n", m_routed_to_master);
+    json_object_set_new(rval, "max_slave_connections", json_integer(m_max_slaves));
-    dcb_printf(pOut, "\tQueries routed to single slave: %d\n", m_routed_to_slave);
+    json_object_set_new(rval, "total_slave_connections", json_integer(m_total_slave_conns));
-    dcb_printf(pOut, "\tQueries routed to named server: %d\n", m_routed_to_named);
+    json_object_set_new(rval, "route_master", json_integer(m_routed_to_master));
-    dcb_printf(pOut, "\tQueries routed to all servers: %d\n", m_routed_to_all);
+    json_object_set_new(rval, "route_slave", json_integer(m_routed_to_slave));
+    json_object_set_new(rval, "route_named_server", json_integer(m_routed_to_named));
+    json_object_set_new(rval, "route_all", json_integer(m_routed_to_all));
+
+    return rval;
 }
 
 Dcb HintRouter::connect_to_backend(MXS_SESSION* session, SERVER_REF* sref,

server/modules/routing/hintrouter/hintrouter.hh

@@ -22,7 +22,7 @@ class HintRouter : public maxscale::Router<HintRouter, HintRouterSession>
 public:
     static HintRouter* create(SERVICE* pService, char** pzOptions);
     HintRouterSession* newSession(MXS_SESSION *pSession);
-    void diagnostics(DCB* pOut);
+    json_t* diagnostics();
     uint64_t getCapabilities() const
     {
         return RCAP_TYPE_NONE;

server/modules/routing/maxinfo/maxinfo.c

@@ -69,7 +69,7 @@ static  MXS_ROUTER_SESSION *newSession(MXS_ROUTER *instance, MXS_SESSION *sessio
 static  void closeSession(MXS_ROUTER *instance, MXS_ROUTER_SESSION *router_session);
 static  void freeSession(MXS_ROUTER *instance, MXS_ROUTER_SESSION *router_session);
 static  int execute(MXS_ROUTER *instance, MXS_ROUTER_SESSION *router_session, GWBUF *queue);
-static  void diagnostics(MXS_ROUTER *instance, DCB *dcb);
+static  json_t* diagnostics(MXS_ROUTER *instance);
 static  uint64_t getCapabilities(MXS_ROUTER* instance);
 static  void handleError(MXS_ROUTER     *instance,
                          MXS_ROUTER_SESSION  *router_session,
@@ -368,10 +368,10 @@ execute(MXS_ROUTER *rinstance, MXS_ROUTER_SESSION *router_session, GWBUF *queue)
  * @param instance  Instance of the router
  * @param dcb       DCB to send diagnostics to
  */
-static  void
+static  json_t*
-diagnostics(MXS_ROUTER *instance, DCB *dcb)
+diagnostics(MXS_ROUTER *instance)
 {
-    return; /* Nothing to do currently */
+    return NULL;
 }
 
 /**

server/modules/routing/readconnroute/readconnroute.c

@@ -93,7 +93,7 @@ static MXS_ROUTER_SESSION *newSession(MXS_ROUTER *instance, MXS_SESSION *session
 static void closeSession(MXS_ROUTER *instance, MXS_ROUTER_SESSION *router_session);
 static void freeSession(MXS_ROUTER *instance, MXS_ROUTER_SESSION *router_session);
 static int routeQuery(MXS_ROUTER *instance, MXS_ROUTER_SESSION *router_session, GWBUF *queue);
-static void diagnostics(MXS_ROUTER *instance, DCB *dcb);
+static json_t* diagnostics(MXS_ROUTER *instance);
 static void clientReply(MXS_ROUTER *instance, MXS_ROUTER_SESSION *router_session, GWBUF *queue,
                         DCB *backend_dcb);
 static void handleError(MXS_ROUTER *instance, MXS_ROUTER_SESSION *router_session, GWBUF *errbuf,
@@ -615,34 +615,23 @@ return_rc:
  * @param instance  Instance of the router
  * @param dcb       DCB to send diagnostics to
  */
-static void
+static json_t* diagnostics(MXS_ROUTER *router)
-diagnostics(MXS_ROUTER *router, DCB *dcb)
 {
-    ROUTER_INSTANCE *router_inst = (ROUTER_INSTANCE *) router;
+    ROUTER_INSTANCE *router_inst = (ROUTER_INSTANCE *)router;
-    char *weightby;
+    json_t* rval = json_object();
 
-    dcb_printf(dcb, "\tNumber of router sessions:   	%d\n",
+    json_object_set_new(rval, "connections", json_integer(router_inst->stats.n_sessions));
-               router_inst->stats.n_sessions);
+    json_object_set_new(rval, "current_connections", json_integer(router_inst->service->stats.n_current));
-    dcb_printf(dcb, "\tCurrent no. of router sessions:	%d\n",
+    json_object_set_new(rval, "queries", json_integer(router_inst->stats.n_queries));
-               router_inst->service->stats.n_current);
+
-    dcb_printf(dcb, "\tNumber of queries forwarded:   	%d\n",
+    char *weightby = serviceGetWeightingParameter(router_inst->service);
-               router_inst->stats.n_queries);
+
-    if ((weightby = serviceGetWeightingParameter(router_inst->service))
+    if (weightby)
-        != NULL)
     {
-        dcb_printf(dcb, "\tConnection distribution based on %s "
+        json_object_set_new(rval, "weightby", json_string(weightby));
-                   "server parameter.\n",
-                   weightby);
-        dcb_printf(dcb,
-                   "\t\tServer               Target %% Connections\n");
-        for (SERVER_REF *ref = router_inst->service->dbref; ref; ref = ref->next)
-        {
-            dcb_printf(dcb, "\t\t%-20s %3.1f%%     %d\n",
-                       ref->server->unique_name,
-                       (float) ref->weight / 10,
-                       ref->connections);
-        }
     }
+
+    return rval;
 }
 
 /**

server/modules/routing/readwritesplit/readwritesplit.c

@@ -74,7 +74,7 @@ static MXS_ROUTER_SESSION *newSession(MXS_ROUTER *instance, MXS_SESSION *session
 static void closeSession(MXS_ROUTER *instance, MXS_ROUTER_SESSION *session);
 static void freeSession(MXS_ROUTER *instance, MXS_ROUTER_SESSION *session);
 static int routeQuery(MXS_ROUTER *instance, MXS_ROUTER_SESSION *session, GWBUF *queue);
-static void diagnostics(MXS_ROUTER *instance, DCB *dcb);
+static json_t* diagnostics(MXS_ROUTER *instance);
 static void clientReply(MXS_ROUTER *instance, MXS_ROUTER_SESSION *router_session, GWBUF *queue,
                         DCB *backend_dcb);
 static void handleError(MXS_ROUTER *instance, MXS_ROUTER_SESSION *router_session,
@@ -646,69 +646,47 @@ static int routeQuery(MXS_ROUTER *instance, MXS_ROUTER_SESSION *router_session,
  * @param   instance    The router instance
  * @param   dcb     The DCB for diagnostic output
  */
-static void diagnostics(MXS_ROUTER *instance, DCB *dcb)
+static json_t* diagnostics(MXS_ROUTER *instance)
 {
     ROUTER_INSTANCE *router = (ROUTER_INSTANCE *)instance;
-    char *weightby;
-    double master_pct = 0.0, slave_pct = 0.0, all_pct = 0.0;
 
-    dcb_printf(dcb, "\n");
+    json_t* rval = json_object();
-    dcb_printf(dcb, "\tuse_sql_variables_in:      %s\n",
-               mxs_target_to_str(router->rwsplit_config.use_sql_variables_in));
-    dcb_printf(dcb, "\tslave_selection_criteria:  %s\n",
-               select_criteria_to_str(router->rwsplit_config.slave_selection_criteria));
-    dcb_printf(dcb, "\tmaster_failure_mode:       %s\n",
-               failure_mode_to_str(router->rwsplit_config.master_failure_mode));
-    dcb_printf(dcb, "\tmax_slave_replication_lag: %d\n",
-               router->rwsplit_config.max_slave_replication_lag);
-    dcb_printf(dcb, "\tretry_failed_reads:        %s\n",
-               router->rwsplit_config.retry_failed_reads ? "true" : "false");
-    dcb_printf(dcb, "\tstrict_multi_stmt:         %s\n",
-               router->rwsplit_config.strict_multi_stmt ? "true" : "false");
-    dcb_printf(dcb, "\tdisable_sescmd_history:    %s\n",
-               router->rwsplit_config.disable_sescmd_history ? "true" : "false");
-    dcb_printf(dcb, "\tmax_sescmd_history:        %d\n",
-               router->rwsplit_config.max_sescmd_history);
-    dcb_printf(dcb, "\tmaster_accept_reads:       %s\n",
-               router->rwsplit_config.master_accept_reads ? "true" : "false");
-    dcb_printf(dcb, "\n");
 
-    if (router->stats.n_queries > 0)
+    json_object_set_new(rval, "use_sql_variables_in",
+                        json_string(mxs_target_to_str(router->rwsplit_config.use_sql_variables_in)));
+    json_object_set_new(rval, "slave_selection_criteria",
+                        json_string(select_criteria_to_str(router->rwsplit_config.slave_selection_criteria)));
+    json_object_set_new(rval, "master_failure_mode",
+                        json_string(failure_mode_to_str(router->rwsplit_config.master_failure_mode)));
+    json_object_set_new(rval, "max_slave_replication_lag",
+                        json_integer(router->rwsplit_config.max_slave_replication_lag));
+    json_object_set_new(rval, "retry_failed_reads",
+                        json_boolean(router->rwsplit_config.retry_failed_reads));
+    json_object_set_new(rval, "strict_multi_stmt",
+                        json_boolean(router->rwsplit_config.strict_multi_stmt));
+    json_object_set_new(rval, "disable_sescmd_history",
+                        json_boolean(router->rwsplit_config.disable_sescmd_history));
+    json_object_set_new(rval, "max_sescmd_history",
+                        json_integer(router->rwsplit_config.max_sescmd_history));
+    json_object_set_new(rval, "master_accept_reads",
+                        json_boolean(router->rwsplit_config.master_accept_reads));
+
+
+    json_object_set_new(rval, "connections", json_integer(router->stats.n_sessions));
+    json_object_set_new(rval, "current_connections", json_integer(router->service->stats.n_current));
+    json_object_set_new(rval, "queries", json_integer(router->stats.n_queries));
+    json_object_set_new(rval, "route_master", json_integer(router->stats.n_master));
+    json_object_set_new(rval, "route_slave", json_integer(router->stats.n_slave));
+    json_object_set_new(rval, "route_all", json_integer(router->stats.n_all));
+
+    char *weightby = serviceGetWeightingParameter(router->service);
+
+    if (weightby)
     {
-        master_pct = ((double)router->stats.n_master / (double)router->stats.n_queries) * 100.0;
+        json_object_set_new(rval, "weightby", json_string(weightby));
-        slave_pct = ((double)router->stats.n_slave / (double)router->stats.n_queries) * 100.0;
-        all_pct = ((double)router->stats.n_all / (double)router->stats.n_queries) * 100.0;
     }
 
-    dcb_printf(dcb, "\tNumber of router sessions:           	%" PRIu64 "\n",
+    return rval;
-               router->stats.n_sessions);
-    dcb_printf(dcb, "\tCurrent no. of router sessions:      	%d\n",
-               router->service->stats.n_current);
-    dcb_printf(dcb, "\tNumber of queries forwarded:          	%" PRIu64 "\n",
-               router->stats.n_queries);
-    dcb_printf(dcb, "\tNumber of queries forwarded to master:	%" PRIu64 " (%.2f%%)\n",
-               router->stats.n_master, master_pct);
-    dcb_printf(dcb, "\tNumber of queries forwarded to slave: 	%" PRIu64 " (%.2f%%)\n",
-               router->stats.n_slave, slave_pct);
-    dcb_printf(dcb, "\tNumber of queries forwarded to all:   	%" PRIu64 " (%.2f%%)\n",
-               router->stats.n_all, all_pct);
-
-    if ((weightby = serviceGetWeightingParameter(router->service)) != NULL)
-    {
-        dcb_printf(dcb, "\tConnection distribution based on %s "
-                   "server parameter.\n",
-                   weightby);
-        dcb_printf(dcb, "\t\tServer               Target %%    Connections  "
-                   "Operations\n");
-        dcb_printf(dcb, "\t\t                               Global  Router\n");
-        for (SERVER_REF *ref = router->service->dbref; ref; ref = ref->next)
-        {
-            dcb_printf(dcb, "\t\t%-20s %3.1f%%     %-6d  %-6d  %d\n",
-                       ref->server->unique_name, (float)ref->weight / 10,
-                       ref->server->stats.n_current, ref->connections,
-                       ref->server->stats.n_current_ops);
-        }
-    }
 }
 
 /**

server/modules/routing/schemarouter/schemarouterinstance.cc

@@ -302,35 +302,30 @@ SchemaRouterSession* SchemaRouter::newSession(MXS_SESSION* pSession)
     return rval;
 }
 
-void SchemaRouter::diagnostics(DCB* dcb)
+json_t* SchemaRouter::diagnostics()
 {
     double sescmd_pct = m_stats.n_sescmd != 0 ?
-                        100.0 * ((double)m_stats.n_sescmd / (double)m_stats.n_queries) :
+        100.0 * ((double)m_stats.n_sescmd / (double)m_stats.n_queries) :
-                        0.0;
+        0.0;
 
-    /** Session command statistics */
+    json_t* rval = json_object();
-    dcb_printf(dcb, "\n\33[1;4mSession Commands\33[0m\n");
+    json_object_set_new(rval, "queries", json_integer(m_stats.n_queries));
-    dcb_printf(dcb, "Total number of queries: %d\n",
+    json_object_set_new(rval, "sescmd_percentage", json_real(sescmd_pct));
-               m_stats.n_queries);
+    json_object_set_new(rval, "longest_sescmd_chain", json_integer(m_stats.longest_sescmd));
-    dcb_printf(dcb, "Percentage of session commands: %.2f\n",
+    json_object_set_new(rval, "times_sescmd_limit_exceeded", json_integer(m_stats.n_hist_exceeded));
-               sescmd_pct);
-    dcb_printf(dcb, "Longest chain of stored session commands: %d\n",
-               m_stats.longest_sescmd);
-    dcb_printf(dcb, "Session command history limit exceeded: %d times\n",
-               m_stats.n_hist_exceeded);
 
     /** Session time statistics */
-
     if (m_stats.sessions > 0)
     {
-        dcb_printf(dcb, "\n\33[1;4mSession Time Statistics\33[0m\n");
+        json_object_set_new(rval, "longest_session", json_real(m_stats.ses_longest));
-        dcb_printf(dcb, "Longest session: %.2lf seconds\n", m_stats.ses_longest);
+        json_object_set_new(rval, "shortest_session", json_real(m_stats.ses_shortest));
-        dcb_printf(dcb, "Shortest session: %.2lf seconds\n", m_stats.ses_shortest);
+        json_object_set_new(rval, "average_session", json_real(m_stats.ses_average));
-        dcb_printf(dcb, "Average session length: %.2lf seconds\n", m_stats.ses_average);
     }
-    dcb_printf(dcb, "Shard map cache hits: %d\n", m_stats.shmap_cache_hit);
+
-    dcb_printf(dcb, "Shard map cache misses: %d\n", m_stats.shmap_cache_miss);
+    json_object_set_new(rval, "shard_map_hits", json_integer(m_stats.shmap_cache_hit));
-    dcb_printf(dcb, "\n");
+    json_object_set_new(rval, "shard_map_misses", json_integer(m_stats.shmap_cache_miss));
+
+    return rval;
 }
 
 uint64_t SchemaRouter::getCapabilities()

server/modules/routing/schemarouter/schemarouterinstance.hh

@@ -37,7 +37,7 @@ public:
     ~SchemaRouter();
     static SchemaRouter* create(SERVICE* pService, char** pzOptions);
     SchemaRouterSession* newSession(MXS_SESSION* pSession);
-    void diagnostics(DCB* pDcb);
+    json_t* diagnostics();
     uint64_t getCapabilities();
 
 private: