How to create a new consumer component

A consumer of events essentially need to implement a subset of event tracking services.

Once such a consumer is installed, producer will use service APIs to notify it about given set of events that the consumer is interested in.

In order to simplify writing the core part of the functionality, we have helper headers with skeleton implementation of each class of events.

See also

EVENT_TRACKING_AUTHENTICATION_CONSUMER_EXAMPLE

EVENT_TRACKING_COMMAND_CONSUMER_EXAMPLE

EVENT_TRACKING_CONNECTION_CONSUMER_EXAMPLE

EVENT_TRACKING_GENERAL_CONSUMER_EXAMPLE

EVENT_TRACKING_GLOBAL_VARIABLE_CONSUMER_EXAMPLE

EVENT_TRACKING_LIFECYCLE_CONSUMER_EXAMPLE

EVENT_TRACKING_MESSAGE_CONSUMER_EXAMPLE

EVENT_TRACKING_PARSE_CONSUMER_EXAMPLE

EVENT_TRACKING_QUERY_CONSUMER_EXAMPLE

EVENT_TRACKING_STORED_PROGRAM_CONSUMER_EXAMPLE

EVENT_TRACKING_TABLE_ACCESS_CONSUMER_EXAMPLE

Following is an example of a consumer that implements various event tracking services, increments simple counters for each event and then displays them through status variables.

#include "mysql/components/services/component_status_var_service.h"
#include "mysql/components/util/event_tracking_authentication_consumer_helper.h"
#include "mysql/components/util/event_tracking_command_consumer_helper.h"
#include "mysql/components/util/event_tracking_connection_consumer_helper.h"
#include "mysql/components/util/event_tracking_general_consumer_helper.h"
#include "mysql/components/util/event_tracking_global_variable_consumer_helper.h"
#include "mysql/components/util/event_tracking_lifecycle_consumer_helper.h"
#include "mysql/components/util/event_tracking_message_consumer_helper.h"
#include "mysql/components/util/event_tracking_parse_consumer_helper.h"
#include "mysql/components/util/event_tracking_query_consumer_helper.h"
#include "mysql/components/util/event_tracking_stored_program_consumer_helper.h"
#include "mysql/components/util/event_tracking_table_access_consumer_helper.h"
 
REQUIRES_SERVICE_PLACEHOLDER_AS(status_variable_registration,
                              mysql_status_var_service);
 
namespace Event_tracking_implementation {
 
enum class Event_types {
  AUTHENTICATION = 0,
  COMMAND,
  CONNECTION,
  GENERAL,
  GLOBAL_VARIABLE,
  MESSAGE,
  PARSE,
  QUERY,
  SHUTDOWN,
  STARTUP,
  STORED_PROGRAM,
  TABLE_ACCESS,
  LAST
};
 
// For the sake of simplicity, locking is ignored
// Ideally one should use atomic variables and use
// status variable of type SHOW_FUNC to fetch and
// display the value
 
unsigned long g_counters[static_cast<unsigned int>(Event_types::LAST)] = {0};
 
static void increment_counter(Event_types event_type) {
  if (event_type < Event_types::LAST) {
    ++g_counters[static_cast<unsigned int>(event_type)];
  }
}
 
  // Status variables
static SHOW_VAR status_vars[] = {
  {"component_event_tracking_example.counter_event_tracking_authentication",
   (char
         )&g_counters[static_cast<unsigned int>(Event_types::AUTHENTICATION)],
   SHOW_LONG, SHOW_SCOPE_GLOBAL},
  {"component_event_tracking_example.counter_event_tracking_command",
   (char
         )&g_counters[static_cast<unsigned int>(Event_types::COMMAND)],
   SHOW_LONG, SHOW_SCOPE_GLOBAL},
  {"component_event_tracking_example.counter_event_tracking_connection",
   (char
         )&g_counters[static_cast<unsigned int>(Event_types::CONNECTION)],
   SHOW_LONG, SHOW_SCOPE_GLOBAL},
  {"component_event_tracking_example.counter_event_tracking_general",
   (char
         )&g_counters[static_cast<unsigned int>(Event_types::GENERAL)],
   SHOW_LONG, SHOW_SCOPE_GLOBAL},
  {"component_event_tracking_example.counter_event_tracking_global_"
   "variable",
   (char
         )&g_counters[static_cast<unsigned int>(Event_types::GLOBAL_VARIABLES)],
   SHOW_LONG, SHOW_SCOPE_GLOBAL},
  {"component_event_tracking_example.counter_event_tracking_message",
   (char
         )&g_counters[static_cast<unsigned int>(Event_types::MESSAGE)],
   SHOW_LONG, SHOW_SCOPE_GLOBAL},
  {"component_event_tracking_example.counter_event_tracking_parse",
   (char
         )&g_counters[static_cast<unsigned int>(Event_types::PARSE)],
   SHOW_LONG, SHOW_SCOPE_GLOBAL},
  {"component_event_tracking_example.counter_event_tracking_query",
   (char
         )&g_counters[static_cast<unsigned int>(Event_types::QUERY)],
   SHOW_LONG, SHOW_SCOPE_GLOBAL},
  {"component_event_tracking_example.counter_event_tracking_"
   "shutdown",
   (char
         )&g_counters[static_cast<unsigned int>(Event_types::SHUTDOWN)],
   SHOW_LONG, SHOW_SCOPE_GLOBAL},
  {"component_event_tracking_example.counter_event_tracking_"
   "startup",
   (char
         )&g_counters[static_cast<unsigned int>(Event_types::STARTUP)],
   SHOW_LONG, SHOW_SCOPE_GLOBAL},
  {"component_event_tracking_example.counter_event_tracking_stored_"
   "program",
   (char
         )&g_counters[static_cast<unsigned int>(Event_types::STORED_PROGRAM)],
   SHOW_LONG, SHOW_SCOPE_GLOBAL},
  {"component_event_tracking_example.counter_event_track_table_"
   "access",
   (char
         )&g_counters[static_cast<unsigned int>(Event_types::TABLE_ACCESS)],
   SHOW_LONG, SHOW_SCOPE_GLOBAL},
  // null terminator required
  {nullptr, nullptr, SHOW_UNDEF, SHOW_SCOPE_UNDEF}};
 
// START: Event tracking implementation
 
mysql_event_tracking_authentication_subclass_t
    Event_tracking_authentication_implementation::filtered_sub_events = 0;
bool Event_tracking_authentication_implementation::callback(
    const mysql_event_tracking_authentication_data *data [[maybe_unused]]) {
  increment_counter(Event_types::AUTHENTICATION);
  return false;
}
 
mysql_event_tracking_command_subclass_t
    Event_tracking_command_implementation::filtered_sub_events = 0;
bool Event_tracking_command_implementation::callback(
    const mysql_event_tracking_command_data *data [[maybe_unused]]) {
  increment_counter(Event_types::COMMAND);
  return false;
}
 
mysql_event_tracking_connection_subclass_t
    Event_tracking_connection_implementation::filtered_sub_events = 0;
bool Event_tracking_connection_implementation::callback(
    const mysql_event_tracking_connection_data *data [[maybe_unused]]) {
  increment_counter(Event_types::CONNECTION);
  return false;
}
 
mysql_event_tracking_general_subclass_t
    Event_tracking_general_implementation::filtered_sub_events = 0;
bool Event_tracking_general_implementation::callback(
    const mysql_event_tracking_general_data *data [[maybe_unused]]) {
  increment_counter(Event_types::GENERAL);
  return false;
}
 
mysql_event_tracking_global_variable_subclass_t
    Event_tracking_global_variable_implementation::filtered_sub_events = 0;
bool Event_tracking_global_variable_implementation::callback(
    const mysql_event_tracking_global_variable_data *data [[maybe_unused]]) {
  increment_counter(Event_types::GLOBAL_VARIABLE);
  return false;
}
 
mysql_event_tracking_startup_subclass_t
    Event_tracking_lifecycle_implementation::startup_filtered_sub_events = 0;
bool Event_tracking_lifecycle_implementation::callback(
    const mysql_event_tracking_startup_data *data [[maybe_unused]]) {
  increment_counter(Event_types::STARTUP);
  return false;
}
 
mysql_event_tracking_shutdown_subclass_t
    Event_tracking_lifecycle_implementation::shutdown_filtered_sub_events = 0;
bool Event_tracking_lifecycle_implementation::callback(
    const mysql_event_tracking_shutdown_data *data [[maybe_unused]]) {
  increment_counter(Event_types::SHUTDOWN);
  return false;
}
 
mysql_event_tracking_message_subclass_t
    Event_tracking_message_implementation::filtered_sub_events = 0;
 
bool Event_tracking_message_implementation::callback(
    const mysql_event_tracking_message_data *data [[maybe_unused]]) {
  increment_counter(Event_types::MESSAGE);
  return false;
}
 
mysql_event_tracking_parse_subclass_t
    Event_tracking_parse_implementation::filtered_sub_events = 0;
bool Event_tracking_parse_implementation::callback(
    mysql_event_tracking_parse_data *data [[maybe_unused]]) {
  increment_counter(Event_types::PARSE);
  return false;
}
 
mysql_event_tracking_query_subclass_t
    Event_tracking_query_implementation::filtered_sub_events = 0;
bool Event_tracking_query_implementation::callback(
    const mysql_event_tracking_query_data *data [[maybe_unused]]) {
  increment_counter(Event_types::QUERY);
  return false;
}
 
mysql_event_tracking_stored_program_subclass_t
    Event_tracking_stored_program_implementation::filtered_sub_events = 0;
bool Event_tracking_stored_program_implementation::callback(
    const mysql_event_tracking_stored_program_data *data [[maybe_unused]]) {
  increment_counter(Event_types::STORED_PROGRAM);
  return false;
}
 
mysql_event_tracking_table_access_subclass_t
    Event_tracking_table_access_implementation::filtered_sub_events = 0;
bool Event_tracking_table_access_implementation::callback(
    const mysql_event_tracking_table_access_data *data [[maybe_unused]]) {
  increment_counter(Event_types::TABLE_ACCESS);
  return false;
}
 
// STOP: Event tracking implementation
 
  static mysql_service_status_t init() {
 
  if ((variables_registered =
         mysql_status_var_service->register_variable(status_vars))) {
    return 1;
  }
 
  return 0;
}
 
static mysql_service_status_t deinit() {
 
  if (mysql_status_var_service->unregister_variable(status_vars)) return 1;
  return 0;
}
 
}  // namespace Event_tracking_implementation
 
// =======================================================================
 
// Component declaration related stuff
 
// This component provides implementation of following component services
IMPLEMENTS_SERVICE_EVENT_TRACKING_AUTHENTICATION(
    component_event_tracking_example);
IMPLEMENTS_SERVICE_EVENT_TRACKING_COMMAND(
    component_event_tracking_example);
IMPLEMENTS_SERVICE_EVENT_TRACKING_CONNECTION(
    component_event_tracking_example);
IMPLEMENTS_SERVICE_EVENT_TRACKING_GENERAL(
    component_event_tracking_example);
IMPLEMENTS_SERVICE_EVENT_TRACKING_GLOBAL_VARIABLE(
    component_event_tracking_example);
IMPLEMENTS_SERVICE_EVENT_TRACKING_LIFECYCLE(
    component_event_tracking_example);
IMPLEMENTS_SERVICE_EVENT_TRACKING_MESSAGE(
    component_event_tracking_example);
IMPLEMENTS_SERVICE_EVENT_TRACKING_PARSE(
    component_event_tracking_example);
IMPLEMENTS_SERVICE_EVENT_TRACKING_QUERY(
    component_event_tracking_example);
IMPLEMENTS_SERVICE_EVENT_TRACKING_STORED_PROGRAM(
    component_event_tracking_example);
IMPLEMENTS_SERVICE_EVENT_TRACKING_TABLE_ACCESS(
    component_event_tracking_example);
 
// This component provides following services
BEGIN_COMPONENT_PROVIDES(component_event_tracking_example)
PROVIDES_SERVICE_EVENT_TRACKING_AUTHENTICATION(
    component_event_tracking_example),
    PROVIDES_SERVICE_EVENT_TRACKING_COMMAND(
        component_event_tracking_example),
    PROVIDES_SERVICE_EVENT_TRACKING_CONNECTION(
        component_event_tracking_example),
    PROVIDES_SERVICE_EVENT_TRACKING_GENERAL(
        component_event_tracking_example),
    PROVIDES_SERVICE_EVENT_TRACKING_GLOBAL_VARIABLE(
        component_event_tracking_example),
    PROVIDES_SERVICE_EVENT_TRACKING_LIFECYCLE(
        component_event_tracking_example),
    PROVIDES_SERVICE_EVENT_TRACKING_MESSAGE(
        component_event_tracking_example),
    PROVIDES_SERVICE_EVENT_TRACKING_PARSE(
        component_event_tracking_example),
    PROVIDES_SERVICE_EVENT_TRACKING_QUERY(
        component_event_tracking_example),
    PROVIDES_SERVICE_EVENT_TRACKING_STORED_PROGRAM(
        component_event_tracking_example),
    PROVIDES_SERVICE_EVENT_TRACKING_TABLE_ACCESS(
        component_event_tracking_example),
    END_COMPONENT_PROVIDES();
 
// List of dependencies
BEGIN_COMPONENT_REQUIRES(component_event_tracking_example)
REQUIRES_SERVICE_AS(status_variable_registration, mysql_status_var_service),
  END_COMPONENT_REQUIRES();
 
// Component description
BEGIN_COMPONENT_METADATA(component_event_tracking_example)
METADATA("mysql.author", "Oracle Corporation"),
    METADATA("mysql.license", "GPL"),
    METADATA("component_event_tracking_example", "1"),
    END_COMPONENT_METADATA();
 
// Component declaration
DECLARE_COMPONENT(component_event_tracking_example,
                  "component_event_tracking_example")
Event_tracking_consumer_a::init,
    Event_tracking_consumer_a::deinit END_DECLARE_COMPONENT();
 
// Component contained in this library
DECLARE_LIBRARY_COMPONENTS &COMPONENT_REF(
    component_event_tracking_example) END_DECLARE_LIBRARY_COMPONENTS