Skip to main content

Centreon Broker Event Mapping

Centreon Broker uses global mapping tables for events that can be exchanged. This page lists properties available for each event type.

NEB​

Acknowledgement​

The acknowledgement of an incident means that the problem has been taken into account by a user of the monitoring service. When the user acknowledges the problem, Centreon Engine emits an acknowledgement event.

NEB::PbAcknowledgement​

CategoryelementID
14565581

This event is a Protobuf event, so items are not serialized as in BBDO v2 events, but using the Protobuf 3 serialization mechanism.

Here is the definition of this protobuf event:

message Acknowledgement {
  uint64 host_id = 1;                // Host ID.
  uint64 service_id = 2;             // Service ID or 0 for a host acknowledgement.
  uint64 instance_id = 3;            // Instance ID.
  enum ResourceType {
    HOST = 0;
    SERVICE = 1;
  }
  ResourceType type = 4;             // Type of the resource.
  string author = 5;                 // Acknowledgement author.
  string comment_data = 6;           // Comment associated with the acknowledgement.
  bool sticky = 7;                   // Sticky flag.
  bool notify_contacts = 8;          // Notification flag.
  uint64 entry_time = 9;             // Time at which the acknowledgement was created.
  uint64 deletion_time = 10;         // Time at which the acknowledgement was deleted.
  bool persistent_comment = 11;      // True if the comment is persistent.
  int32 state = 12;                  // The host / service state.
}

Comment​

In several situations, the user must enter a comment in the Centreon interface. When they validate it, Centreon Engine emits a comment event.

NEB::PbComment​

CategoryelementID
13565571

This event is a Protobuf event, so items are not serialized as in BBDO v2 events, but using the Protobuf 3 serialization mechanism.

The protobuf message is the following:

message BBDOHeader {
  uint32 conf_version = 1;   // A internal number not currently used.
}

message Comment {
  BBDOHeader header = 1;     // Not currently used.

  enum Src {
    INTERNAL = 0;            // The comment originates from the monitoring engine.
    EXTERNAL = 1;            // The comment comes from another source.
  }

  enum Type {
    NO_TYPE = 0;
    HOST = 1;
    SERVICE = 2;
  }

  enum EntryType {
    NO_ENTRY_TYPE = 0;
    USER = 1;
    DOWNTIME = 2;
    FLAPPING = 3;
    ACKNOWLEDGMENT = 4;
  }

  string author = 2;         // Comment author.
  Type type = 3;             // The comment type following the Type enum.
  string data = 4;           // The content of the comment.
  uint64 deletion_time = 5;  // Time a which the comment was deleted or 0 if the comment was not deleted (yet).
  uint64 entry_time = 6;     // Time at which the comment was created.
  EntryType entry_type = 7;  // Entry type following the EntryType enum.
  uint64 expire_time = 8;    // Comment expiration time or 0 if no expiration time.
  bool expires = 9;          // True if the comment expired.
  uint64 host_id = 10;       // Host ID.
  uint64 internal_id = 11;   // Internal monitoring engine ID of the comment.
  bool persistent = 12;      // True if the comment is persistent.
  uint64 instance_id = 13;   // Instance ID.
  uint64 service_id = 14;    // Service ID or 0 for a host comment.
  Src source = 15;           // Source of the comment following the Src enum.
}

Custom variable​

A custom variable is essentially a variable with a name and a value. It often comes from Centreon Engine macros. For Centreon to work correctly, these custom variables must be sent to Centreon Broker. Each one is sent thanks to a custom variable event.

NEB::PbCustomVariable​

CategoryelementID
13765573

This event is a Protobuf event, so items are not serialized as in BBDO v2 events, but using the Protobuf 3 serialization mechanism.

The protobuf message is the following:

message BBDOHeader {
  uint32 conf_version = 1;   // A internal number not currently used.
}

message CustomVariable {
  enum VarType {
    HOST = 0;
    SERVICE = 1;
  }

  BBDOHeader header = 1;     // Not used
  uint64 host_id = 2;        // Host ID.
  uint64 service_id = 3;     // Service ID or 0 for a host custom variable.
  bool modified = 4;         // True if the variable was modified.
  string name = 5;           // Variable name.
  uint64 update_time = 6;    // Last time at which the variable was updated.
  string value = 7;          // Variable value.
  string default_value = 8;  // The default value of the custom variable.
  bool enabled = 9;          // True if the custom variable is enabled.
  bool password = 10;        // True if the value must be hidden.
  VarType type = 11;         // One of the values of the VarType enum.
}

Custom variable status​

Custom variable status events are generated when a custom variable needs to be updated.

NEB::PbCustomVariableStatus​

CategoryelementID
13865574

The Protobuf message for a PbCustomVariableStatus is the same as for a PbCustomVariable, except that some of the fields may not be filled in.

Here is the definition of this protobuf event:

message BBDOHeader {
  uint32 conf_version = 1;   // A internal number not currently used.
}

message CustomVariable {
  enum VarType {
    HOST = 0;
    SERVICE = 1;
  }

  BBDOHeader header = 1;     // Not used
  uint64 host_id = 2;        // Host ID.
  uint64 service_id = 3;     // Service ID or 0 for a host custom variable.
  bool modified = 4;         // True if the variable was modified.
  string name = 5;           // Variable name.
  uint64 update_time = 6;    // Last time at which the variable was updated.
  string value = 7;          // Variable value.
  string default_value = 8;  // The default value of the custom variable.
  bool enabled = 9;          // True if the custom variable is enabled.
  bool password = 10;        // True if the value must be hidden.
  VarType type = 11;         // One of the values of the VarType enum.
}

Downtime​

This event is emitted by Centreon Engine when a downtime is set on a resource.

NEB::PbDowntime​

CategoryelementID
13665572

This event is a Protobuf event, so items are not serialized as in BBDO v2 events, but using the Protobuf 3 serialization mechanism.

The protobuf message is the following:

message Downtime {
  enum DowntimeType {
    NOT_USED = 0;
    SERVICE = 1;                  // The downtime is set on a service.
    HOST = 2;                     // The downtime is set on a host.
    ANY = 3;                      // This is kept for retro compatibility (not used).
  };
  uint64 id = 1;                  // Internal monitoring engine ID.
  uint64 instance_id = 2;         // Instance ID.
  uint64 host_id = 3;             // Host ID.
  uint64 service_id = 4;          // Service ID or 0 if this is host downtime.
  string author = 5;              // Downtime author.
  string comment_data = 6;        // Downtime comment.
  DowntimeType type = 7;          // One value from the previous enum.
  uint32 duration = 8;            // Downtime duration.
  uint64 triggered_by = 9;        // Internal ID of the downtime that triggered this downtime.
  int64 entry_time = 10;          // Time at which the downtime was created.
  uint64 actual_start_time = 11;  // Actual time at which the downtime started.
  uint64 actual_end_time = 12;    // Actual time at which the downtime ended.
  uint64 start_time = 13;         // Scheduled downtime start time.
  uint64 deletion_time = 14;      // Time at which the downtime was deleted.
  uint64 end_time = 15;           // Scheduled downtime end time.
  bool started = 16;              // True if the downtime has been started.
  bool cancelled = 17;            // True if the downtime was canceled.
  bool fixed = 18;                // True if the downtime is fixed, false if it is flexible.
}

Flapping status​

When the status of a resource is unstable, Centreon Engine tags it as flapping. In the past, a flapping status event was emitted in such cases. This no longer occurs. The flapping status event does not exist anymore.

Tag​

The tag is a new configuration event currently used for categories and groups.

At the moment, it is used in parallel with group events and other things, but in the near future it should be more global.

NEB::PbTag​

CategoryelementID
13465570

This event is a Protobuf event, so items are not serialized as in BBDO v2 events, but using the Protobuf 3 serialization mechanism.

The protobuf message is the following:

enum TagType {
  SERVICEGROUP = 0;       // Tag representing a service group
  HOSTGROUP = 1;          // Tag representing a host group
  SERVICECATEGORY = 2;    // Tag representing a service category
  HOSTCATEGORY = 3;       // Tag representing a host category
}

message Tag {
  uint64 id = 1;          // Tag ID (unicity obtained by coupling it with the type)
  enum Action {
    ADD = 0;              // With this action, the event adds a new tag.
    DELETE = 1;           // With this action, the event removes a tag.
    MODIFY = 2;           // With this action, the event modifies a tag.
  }

  Action action = 2;      // The current action for this event.
  TagType type = 3;       // The type of this tag.
  string name = 4;        // Name of this tag.
  int64 poller_id = 5;    // Poller ID.
}

Host​

This event is emitted every time a change is made to the configuration of a host and the configuration is deployed.

NEB::PbHost​

CategoryelementID
13065566

This event is a Protobuf event, so items are not serialized as in BBDO v2 events, but using the Protobuf 3 serialization mechanism.

The protobuf message is the following:

enum AckType {
  NONE = 0;
  NORMAL = 1;
  STICKY = 2;
}

message TagInfo {
  uint64 id = 1;
  TagType type = 2;
}

message Host {
  uint64 host_id = 1;                     // Host ID.

  bool acknowledged = 2;                  // True if the problem has been acknowledged.
  AckType acknowledgement_type = 3;       // Acknowledgement type.

  bool active_checks = 4;                 // True if active checks are enabled.
  bool enabled = 5;                       // True if this host is enabled.
  int32 scheduled_downtime_depth = 6;     // Number of active downtimes.
  string check_command = 7;               // Check command.
  int32 check_interval = 8;               // Interval in units (usually 60 s) between 2 checks.
  string check_period = 9;                // Time period when checks are authorized

  enum CheckType {
    ACTIVE = 0;
    PASSIVE = 1;
  }
  CheckType check_type = 10;              // Type of the last check.
  int32 check_attempt = 11;               // Number of failed checks.
  enum State {
    UP = 0;
    DOWN = 1;
    UNREACHABLE = 2;
  }
  State state = 12;                       // Current state.
  bool event_handler_enabled = 13;        // True if an event handler is configured on this host.
  string event_handler = 14;              // Command executed when state changes.
  double execution_time = 15;             // Duration of the last check.
  bool flap_detection = 16;               // True if flap detection is enabled.
  bool checked = 17;                      // check has been executed at least once.
  bool flapping = 18;                     // True if the host is flapping.
  int64 last_check = 19;                  // Timestamp of the last check.
  State last_hard_state = 20;             // Last hard state.
  int64 last_hard_state_change = 21;      // Timestamp of the last hard state change.
  int64 last_notification = 22;           // Timestamp of the last notification.
  int32 notification_number = 23;         // Current notification number or 0 if not.
  int64 last_state_change = 24;           // Timestamp of the last state change.
  int64 last_time_down = 25;              // Timestamp of the last failed check.
  int64 last_time_unreachable = 26;       // Timestamp of the last failed check with all parent hosts down.
  int64 last_time_up = 27;                // Timestamp of the last successful check.
  int64 last_update = 28;                 // Timestamp of the last message creation.
  double latency = 29;                    // Delay between scheduled check time and real check time.
  int32 max_check_attempts = 30;          // Number of failed checks after which host state becomes a hard fail state.
  int64 next_check = 31;                  // Next scheduled check timestamp.
  int64 next_host_notification = 32;      // Next renotification timestamp.
  bool no_more_notifications = 33;        // If true, no other notification will be sent.
  bool notify = 34;                       // Notifications allowed
  string output = 35;                     // Output of the check command.
  bool passive_checks = 36;               // Passive checks are enabled.
  double percent_state_change = 37;       // Used by flapping and compared with high and low flap thresholds.
  string perfdata = 38;                   // perfdata extracted from the command's output.
  double retry_interval = 39;             // interval between two checks when host isn't in up state and state type is soft.
  bool should_be_scheduled = 40;          // True if next check should be scheduled
  bool obsess_over_host = 41;             // True if OCSP command is executed after check or notification command.

  enum StateType {
    SOFT = 0;                             // State still not confirmed.
    HARD = 1;                             // State confirmed.
  }

  StateType state_type = 42;              // The state type.
  string action_url = 43;                 // Optional url available in the WUI linked to this host.
  string address = 44;                    // An address
  string alias = 45;                      // An alias for this host.
  bool check_freshness = 46;              // Passive freshness check activated
  bool default_active_checks = 47;        // Same as active_checks but the default value.
  bool default_event_handler_enabled = 48;// Same as event_handler but the default value.
  bool default_flap_detection = 49;       // Same as flap_detection but the default value.
  bool default_notify = 50;               // Same as notify but the default value.
  bool default_passive_checks = 51;       // Same as passive checks but the default value.
  string display_name = 52;               // Name displayed in the WUI
  double first_notification_delay = 53;   // Delay before notify in units (usually 60s).
  bool flap_detection_on_down = 54;       // Down state is taken into account for flap detection.
  bool flap_detection_on_unreachable = 55;// Unreachable state is taken into account for flap detection.
  bool flap_detection_on_up = 56;         // Up state is taken into account for flap detection.
  double freshness_threshold = 57;        // Delay after check result is stale.
  double high_flap_threshold = 58;        // If percent state change is higher than this, host is considered flapping.
  string name = 59;                       // Host name.
  string icon_image = 60;                 // Icon displayed in the WUI for the host.
  string icon_image_alt = 61;             // Alternative string for icon_image.
  int32 instance_id = 62;                 // Instance ID.
  double low_flap_threshold = 63;         // If percent state change is lower than this, host is not considered flapping.
  string notes = 64;                      // Tooltip in resources status page.
  string notes_url = 65;                  // clickable url in resources status page.
  double notification_interval = 66;      // Interval between two notifications.
  string notification_period = 67;        // Time period during which notifications are allowed.
  bool notify_on_down = 68;               // Users are notified if the host becomes down.
  bool notify_on_downtime = 69;           // Users are notified if the host enters downtime.
  bool notify_on_flapping = 70;           // Users are notified if the host is flapping.
  bool notify_on_recovery = 71;           // Users are notified if the host becomes up.
  bool notify_on_unreachable = 72;        // Users are notified if the host becomes unreachable.
  bool stalk_on_down = 73;                // Logs check output changes if state is down.
  bool stalk_on_unreachable = 74;         // Logs check output changes if state is unreachable.
  bool stalk_on_up = 75;                  // Logs check output changes if state is up.
  string statusmap_image = 76;            // Image displayed in map.
  bool retain_nonstatus_information = 77; // Unused
  bool retain_status_information = 78;    // Unused
  string timezone = 79;                   // Time zone of the host.
  uint64 severity_id = 80;                // Severity ID.
  repeated TagInfo tags = 81;             // Tags linked to this host.
  uint64 icon_id = 82;                    // Icon ID.
}

Host check​

This type of event is emitted by Centreon Engine when a check is performed on a host.

NEB::PbHostCheck​

CategoryelementID
13965575

This event is a Protobuf event, so items are not serialized as in BBDO v2 events, but using the Protobuf 3 serialization mechanism.

The protobuf message is the following:

message BBDOHeader {
  uint32 conf_version = 1;   // A internal number not currently used.
}

enum CheckType {
    CheckActive = 0;
    CheckPassive = 1;
}

message Check {
    BBDOHeader header = 1;

    bool active_checks_enabled = 2;   // True if active checks are enabled on the host.
    CheckType check_type = 3;         // One of the values in CheckType.
    string command_line = 4;          // Check command line.
    uint64 host_id = 5;               // Host ID.
    uint64 next_check = 6;            // Timestamp at which the next check is scheduled.
    uint64 service_id = 7;            // Service ID or 0 for a host check.
}

Host group​

This event is emitted when a host group is created.

NEB::PbHostGroup​

CategoryelementID
14965585

This event is a Protobuf event, so items are not serialized as in BBDO v2 events, but using the Protobuf 3 serialization mechanism.

The protobuf message is the following:

message BBDOHeader {  
  uint32 conf_version = 1;   // Un nombre interne, non utilisé actuellement.  
}  

message HostGroup {  
  BBDOHeader header = 1;  

  bool enabled = 2;                    // True si le groupe est activé, False s’il ne l’est pas (suppression).  
  uint64 hostgroup_id = 3;             // ID du groupe.  
  string name = 4;                     // Nom du groupe.  
  uint64 poller_id = 5;                // ID du poller.  
  string alias = 6;                    // Alias du groupe.  
}

Host group member​

This is a configuration event. It is sent just after a hostgroup event to detail members of the group to configure. Even in BBDO v3, we still use the BBDO v2 version of this event.

NEB::PBHostGroupMember​

CategoryelementID
15065586

This event is a Protobuf event, so items are not serialized as in BBDO v2 events, but using the Protobuf 3 serialization mechanism.

The protobuf message is the following:

message BBDOHeader {  
  uint32 conf_version = 1;   // Un nombre interne, non utilisé actuellement.  
}  

message HostGroupMember {  
  BBDOHeader header = 1;  

  bool enabled = 2;                    // True si l'hôte est membre du groupe, False s'il ne l’est pas (suppression).  
  uint64 hostgroup_id = 3;       // ID du groupe.  
  string name = 4;                     // Nom du groupe.  
  uint64 poller_id = 6;              // ID de l'instance.  
}

Host parent​

This is a configuration event sent when a host parent is defined. Even in BBDO v3, we still use the BBDO v2 version of this event.

NEB::PbHostParent​

CategoryelementID
15365589

This event is a Protobuf event, so items are not serialized as in BBDO v2 events, but using the Protobuf 3 serialization mechanism.

The protobuf message is the following:

message BBDOHeader {  
  uint32 conf_version = 1;   // Un nombre interne, non utilisé actuellement.  
}  

message HostParent {  
  BBDOHeader header = 1;  

  bool enabled = 2;                     // True si la fonction parent est activée, False si elle ne l’est pas (suppression).  
  uint64 child_id = 3;                  // ID de l'hôte enfant  
  uint64 parent_id = 4;              // ID de l'hôte parent  
}

Host status​

This is an event emitted by Centreon Engine when a host has real time modifications (status, output, metrics, etc.).

NEB::PbHostStatus​

CategoryelementID
13265538

This event is a Protobuf event, so items are not serialized as in BBDO v2 events, but using the Protobuf 3 serialization mechanism.

Here is the definition of this protobuf event:

enum AckType {
  NONE = 0;
  NORMAL = 1;
  STICKY = 2;
}

message HostStatus {
  uint64 host_id = 1;                 // Host ID.

  bool checked = 2;                   // True if the host is checked.
  enum CheckType {
    ACTIVE = 0;
    PASSIVE = 1;
  }
  CheckType check_type = 3;           // Type of the last check (ACTIVE/PASSIVE).

  enum State {
    UP = 0;
    DOWN = 1;
    UNREACHABLE = 2;
  }
  State state = 4;                    // Current state of the host.
  enum StateType {
    SOFT = 0;
    HARD = 1;
  }
  StateType state_type = 5;           // Confirmed or not state (HARD/SOFT).
  int64 last_state_change = 6;        // Timestamp of the last state change.
  State last_hard_state = 7;          // Last hard state.
  int64 last_hard_state_change = 8;   // Timestamp of the last hard state.
  int64 last_time_up = 9;             // Timestamp of the last up state.
  int64 last_time_down = 10;          // Timestamp of the last down state.
  int64 last_time_unreachable = 11;   // Timestamp of the last unreachable state.

  string output = 12;                 // Check output.
  string long_output = 13;            // Check long output.
  string perfdata = 14;               // Performance data.

  bool flapping = 15;                 // True if the host is flapping.
  double percent_state_change = 16;   // Used by flapping and compared with high and low flap thresholds
  double latency = 17;                // Delay between scheduled check time and real check time.
  double execution_time = 18;         // Duration of last check.
  int64 last_check = 19;              // Timestamp of the last check.
  int64 next_check = 20;              // Timestamp at which the next check is scheduled.
  bool should_be_scheduled = 21;      // True if the next check should be scheduled.
  int32 check_attempt = 22;           // Number of failed checks.

  int32 notification_number = 23;     // Number of notifications sent since the start of the problem.
  bool no_more_notifications = 24;    // No other notification will be sent.
  int64 last_notification = 25;       // Timestamp of last notification sent.
  int64 next_host_notification = 26;  // Timestamp of next renotification.

  AckType acknowledgement_type = 27;  // One value of the AckType enum.
  int32 scheduled_downtime_depth = 28;// Number of active downtimes.
}

Instance​

This event is emitted by Centreon Engine when Engine starts to send its configuration or when Engine stops.

NEB::PbInstance​

CategoryelementID
14465580

This event is a Protobuf event, so items are not serialized as in BBDO v2 events, but using the Protobuf 3 serialization mechanism.

Here is the definition of this protobuf event:

message BBDOHeader {
  uint32 conf_version = 1;   // A internal number not currently used.
}

message Instance {
  BBDOHeader header = 1;

  string engine = 2;        // Name of the monitoring engine used on this instance.
  bool running = 3;         // Whether or not this instance is running.
  string name = 4;          // Instance name.
  int64 pid = 5;            // Monitoring engine PID.
  uint64 instance_id = 6;   // Instance ID.
  int64 end_time = 7;       // Timestamp at which the instance shuts down.
  int64 start_time = 8;     // Timestamp at which the instance starts.
  string version = 9;       // Version of the emitter of this message.
}

Instance status​

This event is emitted by Centreon Engine regularly as a watchdog. This event tells Broker that the poller is still alive (with various other information).

NEB::PbInstanceStatus​

CategoryelementID
14265578

This event is a Protobuf event, so items are not serialized as in BBDO v2 events, but using the Protobuf 3 serialization mechanism. When BBDO v3 is used, no more NEB::InstanceStatus events should be sent. Instead, you should see NEB::PbInstanceStatus events.

Here is the definition of this protobuf event:

message BBDOHeader {
  uint32 conf_version = 1;   // A internal number not currently used.
}

message InstanceStatus {
  BBDOHeader header = 1;

  bool event_handlers = 2;                    // Whether or not event handlers are globally enabled.
  bool flap_detection = 3;                    // Whether or not flap detection is globally enabled.
  bool notifications = 4;                     // Whether or not notifications are globally enabled.
  bool active_host_checks = 5;                // Whether or not active host checks are globally enabled.
  bool active_service_checks = 6;             // Whether or not active service checks are globally enabled.
  bool check_hosts_freshness = 7;             // Whether or not hosts freshness checking is globally enabled.
  bool check_services_freshness =  8;         // Whether or not services freshness checking is globally enabled.
  string global_host_event_handler = 9;       // Global host event handler.
  string global_service_event_handler = 10;   // Global service event handler.
  uint64 last_alive = 11;                     // Last time the instance was known alive.
  int64 last_command_check = 12;              // Last time a check command was executed.
  bool obsess_over_hosts = 13;                // Whether or not the monitoring engine should obsess over hosts.
  bool obsess_over_services = 14;             // Whether or not the monitoring engine should obsess over services.
  bool passive_host_checks = 15;              // Whether or not passive host checks are globally enabled.
  bool passive_service_checks = 16;           // Whether or not passive service checks are globally enabled.
  uint64 instance_id = 17;                    // Instance ID.
}

Log entry​

Centreon Engine generates many logs. Some of them are sent to Centreon Broker to be stored in the database. These logs are sent using log entry events.

NEB::PbLogEntry​

CategoryelementID
14165577

This event is a Protobuf event, so items are not serialized as in BBDO v2 events, but using the Protobuf 3 serialization mechanism.

Here is the definition of this protobuf event:

message LogEntry {
  enum LogType {
    SOFT = 0;
    HARD = 1;
  }
  enum MsgType {
    SERVICE_ALERT = 0;
    HOST_ALERT = 1;
    SERVICE_NOTIFICATION = 2;
    HOST_NOTIFICATION = 3;
    WARNING = 4;
    OTHER = 5;
    SERVICE_INITIAL_STATE = 8;
    HOST_INITIAL_STATE = 9;
    SERVICE_ACKNOWLEDGE_PROBLEM = 10;
    HOST_ACKNOWLEDGE_PROBLEM = 11;
    SERVICE_EVENT_HANDLER = 12;
    HOST_EVENT_HANDLER = 13;
    GLOBAL_SERVICE_EVENT_HANDLER = 14;
    GLOBAL_HOST_EVENT_HANDLER = 15;
  }

  uint64 ctime = 1;                     // Log timestamp.
  string instance_name = 2;             // Instance name.
  string output = 3;                    // Output.
  uint64 host_id = 4;                   // Host ID.
  uint64 service_id = 5;                // Service ID or 0 if log entry does not refer to a specific service.
  string host_name = 6;                 // Host name.
  string service_description = 7;       // Service description or empty if log entry does not refer to a specific service.
  string notification_contact = 8;      // Notification contact.
  string notification_cmd = 9;          // Notification command.
  LogType type = 10;                    // One value of LogType.
  MsgType msg_type = 11;                // One value of MsgType.
  int32 status = 12;                    // Host / service status.
  int32 retry = 13;                     // Current check attempt.
}

Service​

This is a configuration event. It is emitted by Centreon Engine when a change is made to the configuration of a service and the configuration is deployed.

NEB::PbService​

CategoryelementID
12765563

This event is a Protobuf event, so items are not serialized as in BBDO v2 events, but using the Protobuf 3 serialization mechanism.

Here is the definition of this protobuf event:

enum ServiceType {
  SERVICE = 0;
  METASERVICE = 2;
  BA = 3;
  ANOMALY_DETECTION = 4;
}

enum AckType {
  NONE = 0;
  NORMAL = 1;
  STICKY = 2;
}

message Service {
  uint64 host_id = 1;                         // Host ID.
  uint64 service_id = 2;                      // Service ID.

  bool acknowledged = 3;                      // Is it currently acknowledged?
  AckType acknowledgement_type = 4;           // AckType value.

  bool active_checks = 5;                     // Are active checks enabled?
  bool enabled = 6;                           // Is this service active?
  int32 scheduled_downtime_depth = 7;         // Number of active downtimes.
  string check_command = 8;                   // Command executed.
  uint32 check_interval = 9;                  // Interval in units (usually 60s) between 2 checks.
  string check_period = 10;                   // Time period when checks are authorized.

  enum CheckType {
    ACTIVE = 0;
    PASSIVE = 1;
  }
  CheckType check_type = 11;                  // CheckType value.
  int32 check_attempt = 12;                   // Number of failed checks.
  enum State {
    OK = 0;
    WARNING = 1;
    CRITICAL = 2;
    UNKNOWN = 3;
    PENDING = 4;
  }
  State state = 13;                           // Current state of this service.
  bool event_handler_enabled = 14;            // Event handler enabled?
  string event_handler = 15;                  // Command executed when state changes.
  double execution_time = 16;                 // Duration of last check.
  bool flap_detection = 17;                   // Is flap detection enabled?
  bool checked = 18;                          // Is this service checked?
  bool flapping = 19;                         // Is this service flapping?
  int64 last_check = 20;                      // Timestamp of the last check.
  State last_hard_state = 21;                 // Last hard state.
  int64 last_hard_state_change = 22;          // Timestamp of the last hard state change.
  int64 last_notification = 23;               // Timestamp of the last notification.
  int32 notification_number = 24;             // Number of notifications sent since the start of the problem.
  int64 last_state_change = 25;               // Timestamp of the last state change.
  int64 last_time_ok = 26;                    // Timestamp of the last check OK return code.
  int64 last_time_warning = 27;               // Timestamp of the last check WARNING return code.
  int64 last_time_critical = 28;              // Timestamp of the last check CRITICAL return code.
  int64 last_time_unknown = 29;               // Timestamp of the last check UNKNOWN return code.
  int64 last_update = 30;                     // Timestamp of this event creation.
  double latency = 31;                        // Delay between scheduled check time and real check time.
  uint32 max_check_attempts = 32;             // Number of failed checks after which service state becomes a hard fail state.
  int64 next_check = 33;                      // Next scheduled check timestamp.
  int64 next_notification = 34;               // Next notification timestamp.
  bool no_more_notifications = 35;            // No other notification will be sent.
  bool notify = 36;                           // Are notifications enabled on this service?
  string output = 37;                         // Output of the check command.
  string long_output = 38;                    // Long output of the check command.
  bool passive_checks = 39;                   // Are passive checks enabled?
  double percent_state_change = 40;           // Used by flapping and compared with high and low flap thresholds.
  string perfdata = 41;                       // Perfdata extracted from the command's output.
  double retry_interval = 42;                 // Interval between two checks when service isn't in ok state and state type is SOFT.
  string host_name = 43;                      // Host name of this service.
  string description = 44;                    // Description of this service
  bool should_be_scheduled = 45;              // Is there a next check scheduled?
  bool obsess_over_service = 46;              // True if OCSP command is executed after check or notification command.

  enum StateType {
    SOFT = 0;
    HARD = 1;
  }

  StateType state_type = 47;                  // StateType value.
  string action_url = 48;                     // Url to obtain information about this service.
  bool check_freshness = 49;                  // Passive freshness check activated?
  bool default_active_checks = 50;            // Default value of active_checks.
  bool default_event_handler_enabled = 51;    // Default value of event_handler_enabled.
  bool default_flap_detection = 52;           // Default value of flap detection.
  bool default_notify = 53;                   // Default value of notify.
  bool default_passive_checks = 54;           // Default value of passive checks.
  string display_name = 55;                   // Name displayed in WUI.
  double first_notification_delay = 56;       // Delay before notify in units (usually 60s).
  bool flap_detection_on_critical = 57;       // Critical state is taken into account for flap detection.
  bool flap_detection_on_ok = 58;             // Ok state is taken into account for flap detection.
  bool flap_detection_on_unknown = 59;        // Unknown state is taken into account for flap detection.
  bool flap_detection_on_warning = 60;        // Warning state is taken into account for flap detection.
  double freshness_threshold = 61;            // Delay after check result is stale.
  double high_flap_threshold = 62;            // If percent state change is higher than this, service is considered flapping.
  string icon_image = 63;                     // Icon displayed in the WUI for the service.
  string icon_image_alt = 64;                 // Alternate string for icon_image.
  bool is_volatile = 65;                      // Is the service volatile?
  double low_flap_threshold = 66;             // If percent state change is lower than this, service is not considered flapping.
  string notes = 67;                          // Tooltip in resources status page.
  string notes_url = 68;                      // Clickable url in resources status page.
  double notification_interval = 69;          // Interval between two notifications.
  string notification_period = 70;            // Time period during which notifications are allowed.
  bool notify_on_critical = 71;               // Users are notified if service state becomes critical.
  bool notify_on_downtime = 72;               // Users are notified if service enters in downtime.
  bool notify_on_flapping = 73;               // Users are notified if service is flapping.
  bool notify_on_recovery = 74;               // Users are notified if service becomes OK.
  bool notify_on_unknown = 75;                // Users are notified if service state becomes unknown.
  bool notify_on_warning = 76;                // Users are notified if service state becomes warning.
  bool stalk_on_critical = 77;                // Users are notified if service state becomes critical.
  bool stalk_on_ok = 78;                      // Logs check output event change if state is OK.
  bool stalk_on_unknown = 79;                 // Logs check output event change if state is unknown.
  bool stalk_on_warning = 80;                 // Logs check output event change if state is warning.
  bool retain_nonstatus_information = 81;     // unused.
  bool retain_status_information = 82;        // unused.
  uint64 severity_id = 83;                    // Severity ID or 0.
  repeated TagInfo tags = 84;                 // Tag IDs.

  ServiceType type = 85;                      // What kind of service is it?

  /* In case of metaservice and ba, they also have an internal id. We keep it
   * here. */
  uint64 internal_id = 86;                    // ID of metaservice or ba.
  uint64 icon_id = 87;                        // Icon ID.
}

Service check​

This event is emitted by Centreon Engine when a check is performed on a service.

NEB::PbServiceCheck​

CategoryelementID
14065576

This event is a Protobuf event, so items are not serialized as in BBDO v2 events, but using the Protobuf 3 serialization mechanism. When BBDO v3 is used, no more NEB::ServiceCheck events should be sent. Instead, you should see NEB::PbServiceCheck events.

Here is the definition of this protobuf event:

message BBDOHeader {
  uint32 conf_version = 1;   // A internal number not currently used.
}

enum CheckType {
    CheckActive = 0;
    CheckPassive = 1;
}

message Check {
    BBDOHeader header = 1;

    bool active_checks_enabled = 2;   // True if active checks are enabled on the host.
    CheckType check_type = 3;         // One of the values in CheckType.
    string command_line = 4;          // Check command line.
    uint64 host_id = 5;               // Host ID.
    uint64 next_check = 6;            // Timestamp at which the next check is scheduled.
    uint64 service_id = 7;            // Service ID or 0 for a host check.
}

Service group​

This is a configuration event that is emitted when a service group is created.

NEB::PbServiceGroup​

CategoryelementID
15165587

This event is a Protobuf event, so items are not serialized as in BBDO v2 events, but using the Protobuf 3 serialization mechanism.

Here is the definition of this protobuf event:

message BBDOHeader {  
  uint32 conf_version = 1;   // Un nombre interne, non utilisé actuellement.  
}  

message ServiceGroup {  
  BBDOHeader header = 1;  

  bool enabled = 2;                     // True si le groupe est activé, False s’il ne l’est pas (suppression).  
  uint64 servicegroup_id = 3;   // ID du groupe.  
  string name = 4;                      // Nom du groupe.  
  uint64 poller_id = 5;                // ID du poller.  
}

Service group member​

This is a configuration event. It is sent just after a servicegroup event to detail members of the group to configure. Even in BBDO v3, we still use the BBDO v2 version of this event.

NEB::PbServiceGroupMember​

CategoryelementID
15065586

This event is a Protobuf event, so items are not serialized as in BBDO v2 events, but using the Protobuf 3 serialization mechanism.

Here is the definition of this protobuf event:

message BBDOHeader {  
  uint32 conf_version = 1;   // Un nombre interne, non utilisé actuellement.  
}  

message ServiceGroupMember {  
  BBDOHeader header = 1;  

  bool enabled = 2;                    // True si le groupe est activé, False s’il ne l’est pas (suppression).  
  uint64 servicegroup_id = 3;             // ID du groupe.  
  string name = 4;                     // Nom du groupe.  
  uint64 host_id = 5;                 // ID de l'hôte.  
  uint64 poller_id = 6;                // ID du poller.  
  uint64 service_id = 7;                    // ID du service.  
}

Service status​

This is an event emitted by Centreon Engine when a service has real time modifications.

NEB::PbServiceStatus​

CategoryelementID
12965565

This event is a Protobuf event, so items are not serialized as in BBDO v2 events, but using the Protobuf 3 serialization mechanism. When BBDO v3 is used, no more NEB::ServiceStatus events should be sent. Instead , you should see NEB::PbServiceStatus.

Here is the definition of this protobuf event:

message ServiceStatus {
  uint64 host_id = 1;                         // Host ID.
  uint64 service_id = 2;                      // Service ID.

  bool checked = 3;                          // Is this service checked?
  enum CheckType {
    ACTIVE = 0;
    PASSIVE = 1;
  }
  CheckType check_type = 4;                  // CheckType value.

  enum State {
    OK = 0;
    WARNING = 1;
    CRITICAL = 2;
    UNKNOWN = 3;
    PENDING = 4;
  }
  State state = 5;                           // Current state of this service.
  enum StateType {
    SOFT = 0;
    HARD = 1;
  }
  StateType state_type = 6;                  // StateType value.
  int64 last_state_change = 7;               // Timestamp of the last state change.
  State last_hard_state = 8;                 // Last hard state.
  int64 last_hard_state_change = 9;          // Timestamp of the last hard state change.
  int64 last_time_ok = 10;                   // Timestamp of the last check OK return code.
  int64 last_time_warning = 11;              // Timestamp of the last check WARNING return code.
  int64 last_time_critical = 12;             // Timestamp of the last check CRITICAL return code.
  int64 last_time_unknown = 13;              // Timestamp of the last check UNKNOWN return code.

  string output = 14;                        // Output of the check command.
  string long_output = 15;                   // Long output of the check command.
  string perfdata = 16;                      // Perfdata extracted from the command's output.

  bool flapping = 17;                        // Is this service flapping?
  double percent_state_change = 18;          // Used by flapping and compared with high and low flap thresholds.
  double latency = 19;                       // Delay between scheduled check time and real check time.
  double execution_time = 20;                // Duration of last check.
  int64 last_check = 21;                     // Timestamp of the last check.
  int64 next_check = 22;                     // Next scheduled check timestamp.
  bool should_be_scheduled = 23;             // Is there a next check scheduled?
  int32 check_attempt = 24;                  // Number of failed checks after which service state becomes a hard fail state.

  int32 notification_number = 25;            // Number of notifications sent since the start of the problem.
  bool no_more_notifications = 26;           // No other notification will be sent.
  int64 last_notification = 27;              // Timestamp of the last notification.
  int64 next_notification = 28;              // Next notification timestamp.

  AckType acknowledgement_type = 29;         // AckType value.
  int32 scheduled_downtime_depth = 30;       // Number of active downtimes.

  ServiceType type = 31;                     // What kind of service is it?

  /* In case of metaservice and ba, they also have an internal id. We keep it
   * here. */
  uint64 internal_id = 32;                   // ID of metaservice or ba.
}

Instance configuration​

Here is a configuration event announcing all the configuration events that are going to be sent by a poller.

NEB::PbInstanceConfiguration​

CategoryelementID
15465590

This event is a Protobuf event, so items are not serialized as in BBDO v2 events, but using the Protobuf 3 serialization mechanism. When BBDO v3 is used, no more NEB::ServiceStatus events should be sent. Instead , you should see NEB::PbServiceStatus.

Here is the definition of this protobuf event:

message BBDOHeader {  
  uint32 conf_version = 1;   // Un nombre interne, non utilisé actuellement.  
}  

message InstanceConfiguration {  
  BBDOHeader header = 1;  

  bool loaded = 2;           // True si l’instance s’est chargée avec succès.  
  uint64 poller_id = 3;      // ID du collecteur qui a reçu une demande de mise à jour de la configuration (reload).  
}

Responsive instance​

This event is emitted by cbd. It tells if a poller is responsive or not.

NEB::PbResponsiveInstance​

CategoryelementID
14665582

This event is a Protobuf event, so items are not serialized as in BBDO v2 events, but using the Protobuf 3 serialization mechanism. When BBDO v3 is used, no more NEB::ResponsiveInstance events should be sent. Instead, you should see NEB::PbResponsiveInstance events.

Here is the definition of this protobuf event:

message BBDOHeader {
  uint32 conf_version = 1;   // An internal number, not currently used.
}

message ResponsiveInstance {
  BBDOHeader header = 1;

  uint64 poller_id = 2;      // Poller ID.
  bool responsive = 3;       // Is this poller responsive?
}

Adaptive service​

This event was introduced with BBDO v3. It is emitted when a service has its configuration updated on the fly (for example with an external command)

NEB::PbAdaptiveService​

CategoryelementID
14165577

This event is a Protobuf event, so items are not serialized as in BBDO v2 events, but using the Protobuf 3 serialization mechanism. When BBDO v3 is used, no more NEB::AdaptiveService events should be sent. Instead, you should see NEB::PbAdaptiveService events.

The protobuf message is the following:

message AdaptiveService {
  uint64 host_id = 1;                         // Host ID.
  uint64 service_id = 2;                      // Service ID.

  optional bool notify = 3;                   // Are notifications enabled on this service?
  optional bool active_checks = 4;            // Are active checks enabled?
  optional bool should_be_scheduled = 5;      // Is there a next check scheduled?
  optional bool passive_checks = 6;           // Are passive checks enabled?
  optional bool event_handler_enabled = 7;    // Event handler enabled?
  optional bool flap_detection_enabled = 8;   // Is flap detection enabled?
  optional bool obsess_over_service = 9;      // True if OCSP command is executed after check or notification command.
  optional string event_handler = 10;         // Command executed when state changes.
  optional string check_command = 11;         // Command executed.
  optional uint32 check_interval = 12;        // Interval in units (usually 60s) between 2 checks.
  optional uint32 retry_interval = 13;        // Interval between two checks when service isn't in ok state and state type is SOFT.
  optional uint32 max_check_attempts  = 14;   // Number of failed checks after which service state becomes a hard fail state.
  optional bool check_freshness = 15;         // Passive freshness check activated?
  optional string check_period = 16;          // Time period when checks are authorized.
  optional string notification_period = 17;   // Time period when notifications are authorized.
}

Adaptive host​

This event was introduced with BBDO v3. It is emitted when a host has its configuration updated on the fly (for example with an external command).

NEB::PbAdaptiveHost​

CategoryelementID
13165567

This event is a Protobuf event, so items are not serialized as in BBDO v2 events, but using the Protobuf 3 serialization mechanism. When BBDO v3 is used, no more NEB::AdaptiveHost events should be sent. Instead, you should see NEB::PbAdaptiveHost events.

The protobuf message is the following:

message AdaptiveHost {
  uint64 host_id = 1;                         // Host ID.

  optional bool notify = 2;                   // Are notifications enabled on this service?
  optional bool active_checks = 3;            // Are active checks enabled?
  optional bool should_be_scheduled = 4;      // Is there a next check scheduled?
  optional bool passive_checks = 5;           // Are passive checks enabled?
  optional bool event_handler_enabled = 6;    // Event handler enabled?
  optional bool flap_detection = 7;           // Is flap detection enabled?
  optional bool obsess_over_host = 8;         // True if OCSP command is executed after check or notification command.
  optional string event_handler = 9;          // Command executed when state changes.
  optional string check_command  = 10;        // Command executed.
  optional uint32 check_interval  = 11;       // Interval in units (usually 60s) between 2 checks.
  optional uint32 retry_interval  = 12;       // Interval between two checks when service isn't in ok state and state type is SOFT.
  optional uint32 max_check_attempts  = 13;   // Number of failed checks after which service state becomes a hard fail state.
  optional bool check_freshness = 14;         // Passive freshness check activated?
  optional string check_period  = 15;         // Time period when checks are authorized.
  optional string notification_period  = 16;  // Time period when notifications are authorized.
}

Severity​

This is a configuration event. It defines a severity. This event was introduced with BBDO v3.

NEB::PbSeverity​

CategoryelementID
13365569

This event comes with BBDO 3. It contains the severity of a resource.

Here is the definition of this protobuf event:

message Severity {
  uint64 id = 1;
  enum Action {
    ADD = 0;
    DELETE = 1;
    MODIFY = 2;
  }
  Action action = 2;
  uint32 level = 3;
  uint64 icon_id = 4;
  string name = 5;
  enum Type {
    SERVICE = 0;
    HOST = 1;
  }
  Type type = 6;
  uint64 poller_id = 7;
}

Adaptive service status​

This is a real time event. It contains a small part of a service status. It was introduced with BBDO v3.

NEB::PbAdaptiveServiceStatus​

CategoryelementID
15565591

This event comes with BBDO 3. It contains a small part of a service status.

Here is the definition of this protobuf event:

message AdaptiveServiceStatus {
  uint64 host_id = 1;
  uint64 service_id = 2;
  ServiceType type = 3;
  uint64 internal_id = 4;
  optional int32 scheduled_downtime_depth = 5;
  optional AckType acknowledgement_type = 6;
  optional int32 notification_number = 7;
}

Adaptive host status​

This is a real time event. It contains a small part of a host status. It was introduced with BBDO v3.

NEB::PbAdaptiveHostStatus​

CategoryelementID
15665592

This event comes with BBDO 3. It contains a small part of a host status.

Here is the definition of this protobuf event:

message AdaptiveHostStatus {
  uint64 host_id = 1;
  optional int32 scheduled_downtime_depth = 2;
  optional AckType acknowledgement_type = 3;
  optional int32 notification_number = 4;
}

Storage​

Metric​

This event is generated by a Storage endpoint to notify that an RRD metric graph should be updated.

Storage::PbMetric​

CategoryelementID
39196617

This event is a Protobuf event so items are not serialized as in BBDO v2 events, but using the Protobuf 3 serialization mechanism. When BBDO v3 is used, no more Storage::Metric events should be sent. Instead, you should see Storage::PbMetric events.

Here is the definition of this protobuf event:

message Metric {
  enum ValueType {
    GAUGE = 0;
    COUNTER = 1;
    DERIVE = 2;
    ABSOLUTE = 3;
    AUTOMATIC = 4;
  }
  uint64 metric_id = 4;       // Metric ID.
  int32 rrd_len = 5;          // RRD retention length in seconds.
  int32 interval = 6;         // Normal service check interval in seconds.
  ValueType value_type = 7;   // A value from ValueType.
  uint64 time = 8;            // Timestamp at which the metric value was generated.
  double value = 9;           // Metric value.
  string name = 10;           // Metric name.
  uint64 host_id = 11;        // Host ID.
  uint64 service_id = 12;     // Service ID.
}

Rebuild​

Rebuild events are generated when a Storage endpoint detects that some graphs should be rebuilt. It first sends a rebuild start event (end false), then metric values (metric event with is_for_rebuild set to true) and finally a rebuild end event (end true).

This message and its principle are only available in BBDO v2. With BBDO v3, we take advantage of the power of Protobuf. To rebuild graphs, we use the event Storage::PbRebuildMessage.

Storage::Rebuild​

CategoryelementID
32196610

The content of this message is serialized as follows:

PropertyTypeDescriptionVersion
endbooleanEnd flag. Set to true if rebuild is starting, false if it is ending.
idunsigned integerID of metric to rebuild if is_index is false, or ID of index to rebuild (status graph) if is_index is true.
is_indexbooleanIndex flag. Rebuild index (status) if true, rebuild metric if false.

Remove graph​

A Storage endpoint generates a remove graph event when some graphs must be deleted.

This message and its principle are only available in BBDO v2. With BBDO v3, we take advantage of the power of Protobuf. To remove graphs, we use the event Storage::PbRemoveGraphMessage.

Storage::RemoveGraph​

CategoryelementID
33196611

The content of this message is serialized as follows:

PropertyTypeDescription
idunsigned integerIndex ID (is_index =true) or metric ID (is_index =false) to remove.
is_indexbooleanIndex flag. If true, a index (status) graph will be deleted. If false, a metric graph will be deleted.

Status​

This event is emitted by cbd when a Service Status or a Host Status event is received. It essentially contains a resource with its status.

Storage::PbStatus​

CategoryelementID
310196618

This event is a Protobuf event, so items are not serialized as in BBDO v2 events, but using the Protobuf 3 serialization mechanism.

Here is the definition of this protobuf event:

message Status {
  uint64 index_id = 1;      // Index ID.
  uint32 interval = 2;      // Normal service check interval in seconds.
  uint32 rrd_len = 3;       // RRD retention in seconds.
  uint64 time = 4;          // Timestamp at which the status was generated.
  uint32 state = 5;         // Service state.
}

Metric mapping​

This event is emitted by Centreon Broker when a new service configuration is received. It associates an index ID (the one created for a service - see Index mapping) to a metric ID.

Storage::PbMetricMapping​

CategoryelementID
312196620

This event is a Protobuf event so items are not serialized as in BBDO v2 events, but using the Protobuf 3 serialization mechanism. When BBDO v3 is used, no more Storage::MetricMapping events should be sent. Instead, you should see Storage::PbIndexMapping events.

Here is the definition of this protobuf event:

message MetricMapping {
  uint64 index_id = 1;    // Index ID of the service.
  uint64 metric_id = 2;   // Metric ID linked to the service.
}

Index mapping​

This event is emitted by Centreon Broker when a new service configuration is received. It associates an ID to the pair (host ID/service ID). This new ID is useful for the service metrics declaration.

Storage::PbIndexMapping​

CategoryelementID
311196619

This event is a Protobuf event so items are not serialized as in BBDO v2 events, but using the Protobuf 3 serialization mechanism.

Here is the definition of this protobuf event:

message IndexMapping {
  uint64 index_id = 1;      // Index ID for a service.
  uint64 host_id = 2;       // Host ID of the service.
  uint64 service_id = 3;    // Service ID of the service.
}

Rebuild Message​

This event comes with BBDO 3, when some graphs have to be rebuilt. Messages handling these rebuilds are of that type. They replace the old BBDO v2 rebuild message.

Storage::PbRebuildMessage​

CategoryelementID
37196615

There are three states for this message:

  • START: here is the first state. This message initializes which metrics have to be rebuilt.
  • DATA: once the START state has been sent, one or more messages with DATA state may be sent to the RRD broker.
  • END: When all the rebuild events have been sent, this one is sent to close the rebuilds. And the RRD broker falls back into a nominal state.

The protobuf message is the following:

message Point {
  int64 ctime = 1;
  double value = 2;
}

message Timeserie {
  repeated Point pts = 1;
  int32 data_source_type = 2;
  uint32 check_interval = 3;
  uint32 rrd_retention = 4;
}

message RebuildMessage {
  enum State {
    START = 0;
    DATA = 1;
    END = 2;
  }
  State state = 1;
  /* Only used on DATA state */
  map<uint64, Timeserie> timeserie = 2;

  /* Only used on START/END state */
  repeated uint64 metric_id = 3;
}

Remove Graph Message​

This event comes with BBDO 3. When we want to remove graph files, we can use the centengine gRPC API and this call makes cbd generate a Storage::PbRemoveGraphMessage event. There are two possibilities concerning this event. We can remove graphs matching some index data or graphs matching some metric data. It is also possible to mix the two kinds.

Storage::PbRemoveGraphMessage​

CategoryelementID
38196616

Here is the definition of this protobuf event:

message RemoveGraphMessage {
  repeated uint64 index_ids = 1;
  repeated uint64 metric_ids = 2;
}

BBDO​

Version response​

This is the negotiation message used until BBDO v3.0.0. Each time a BBDO connection is established, this message is sent by the connector and by the acceptor to negotiate options.

BBDO::VersionResponse​

CategoryelementID
21131073

The content of this message is serialized as follows:

PropertyTypeDescription
bbdo_majorshort integerBBDO protocol major used by the peer sending this version_response packet. The sole current protocol version is 1.0.0.
bbdo_minorshort integerBBDO protocol minor used by the peer sending this version_response packet.
bbdo_patchshort integerBBDO protocol patch used by the peer sending this version_response packet.
extensionsstringSpace-separated string of extensions supported by the peer sending this version_response packet.

Ack​

Usually, a BBDO sender sends events and a BBDO receiver consumes events. But the sender keeps events until the receiver tells it they have been handled. To do that, the receiver emits an Ack message with the number of events already handled.

NEB::PbAck​

CategoryelementID
28131080

This event is a Protobuf event, so items are not serialized as in BBDO v2 events, but using the Protobuf 3 serialization mechanism.

The protobuf message is the following:

message Ack {
  uint32 acknowledged_events = 1;   // The number of events to acknowledge.
}

Stop​

When one side of a BBDO connection is going to exit, it emits a Stop event so that if the other side has events already handled it can send an Ack event.

BBDO::PbStop​

CategoryelementID
29131081

This event is a Protobuf event, so items are not serialized as in BBDO v2 events, but using the Protobuf 3 serialization mechanism. When BBDO v3 is used, no more BBDO::Stop events should be sent. Instead, you should see BBDO::PbStop events.

The protobuf message is the following:

message Stop {}

BAM​

BA status event​

This event is sent when a BA's status changes.

BAM::PbBaStatus​

CategoryelementID
619393235

This event is a Protobuf event, so items are not serialized as in BBDO v2 events, but using the Protobuf 3 serialization mechanism. When BBDO v3 is used, no more BAM::BaStatus events should be sent. Instead, you should see BAM::PbBaStatus events.

The protobuf message is the following:

enum State {
    OK = 0;
    WARNING = 1;
    CRITICAL = 2;
    UNKNOWN = 3;
}

message BaStatus {
    uint32 ba_id = 2;                   // The ID of the BA.
    bool in_downtime = 3;               // True if the BA is in downtime.
    uint64 last_state_change = 4;       // Timestamp of the last state change of the BA.
    double level_acknowledgement = 5;   // The acknowledgement level of the BA.
    double level_downtime = 6;          // The downtime level of the BA.
    double level_nominal = 7;           // The nominal level of the BA.
    State state = 8;                    // The state of the BA.
    bool state_changed = 9;             // True if the state of the BA just changed.
}

KPI status event​

This event is sent when a KPI's status changes.

BAM::PbKpiStatus​

CategoryelementID
627393243

This event is a Protobuf event, so items are not serialized as in BBDO v2 events, but using the Protobuf 3 serialization mechanism. When BBDO v3 is used, no more BAM::KpiStatus events should be sent. Instead, you should see BAM::PbKpiStatus events.

The protobuf message is the following:

enum State {
    OK = 0;
    WARNING = 1;
    CRITICAL = 2;
    UNKNOWN = 3;
}

message KpiStatus {
    uint32 kpi_id = 1;                      // ID of the KPI.
    bool in_downtime = 2;                   // True if the KPI is in downtime.
    double level_acknowledgement_hard = 3;  // The hard acknowledgement level of the KPI.
    double level_acknowledgement_soft = 4;  // The soft acknowledgement level of the KPI.
    double level_downtime_hard = 5;         // The hard downtime level of the KPI.
    double level_downtime_soft = 6;         // The soft downtime level of the KPI.
    double level_nominal_hard = 7;          // The hard nominal level of the KPI.
    double level_nominal_soft = 8;          // The soft nominal level of the KPI.
    State state_hard = 9;                   // Hard state of the KPI.
    State state_soft = 10;                  // Soft state of the KPI.
    int64 last_state_change = 11;           // Timestamp of the last state change of the KPI.
    double last_impact = 12;                // Last impact of the KPI.
    bool valid = 13;                        // True if the KPI is valid.
}

Meta service status event​

This event was designed to send meta service's status changes.

At the moment meta services are not managed by Centreon Broker, so this event is not used.

BAM::MetaServiceStatus​

CategoryelementID
63393219

The content of this message is serialized as follows:

PropertyTypeDescription
meta_service_idunsigned integerThe id of the meta service.
valuerealThe value of the meta service.
state_changedbooleanTrue if the state just changed.

BA-event event​

This event is sent when a new BA event is opened, or an old one is closed.

BAM::PbBaEvent​

CategoryelementID
620393236

This event is a Protobuf event, so items are not serialized as in BBDO v2 events, but using the Protobuf 3 serialization mechanism. When BBDO v3 is used, no more BAM::BaEvent events should be sent. Instead, you should see BAM::PbBaEvent events.

The protobuf message is the following:

enum State {
    OK = 0;
    WARNING = 1;
    CRITICAL = 2;
    UNKNOWN = 3;
}

message BaEvent {
    uint32 ba_id = 1;         // The ID of the BA.
    double first_level = 2;   // The first level of the BA event.
    int64 end_time = 3;       // The end\_time of the event. 0 or (time)-1 for an opened event.
    bool in_downtime = 4;     // True if BA was in downtime during the BA event.
    uint64 start_time = 5;    // The start\_time of the event.
    State status = 6;         // The status of the BA during the event.
}

KPI Event​

This event is sent when a new KPI event is opened, or an old one is closed.

BAM::PbKpiEvent​

CategoryelementID
621393237

This event is a Protobuf event, so items are not serialized as in BBDO v2 events, but using the Protobuf 3 serialization mechanism. When BBDO v3 is used, no more BAM::KpiEvent events should be sent. Instead, you should see BAM::PbKpiEvent events.

The protobuf message is the following:

enum State {
    OK = 0;
    WARNING = 1;
    CRITICAL = 2;
    UNKNOWN = 3;
}

message KpiEvent {
    uint32 ba_id = 1;         // The id of the BA.
    uint64 start_time = 2;    // The start\_time of the event.
    int64 end_time = 3;       // The end\_time of the event. 0 or (time)-1 for an opened event.
    uint32 kpi_id = 4;        // The id of the KPI.
    int32  impact_level = 5;  // The level of the impact.
    bool in_downtime = 6;     // True if BA was in downtime during the BA event.
    string output = 7;        // The first output of the KPI during the event.
    string perfdata = 8;      // The first perfdata of the KPI during the event.
    State status = 9;         // The status of the BA during the event.
}

BA duration event event​

This event is sent when a new BA duration event is computed by the BAM broker.

BAM::PbBaDurationEvent​

CategoryelementID
628393244

This event is a Protobuf event, so items are not serialized as in BBDO v2 events, but using the Protobuf 3 serialization mechanism. When BBDO v3 is used, no more BAM::BaDurationEvent events should be sent. Instead, you should see BAM::PbBaDurationEvent events.

The protobuf message is the following:

message BaDurationEvent {
    uint32 ba_id = 1;                 // The ID of the BA.
    int64 real_start_time = 2;        // Effective start timestamp of the event.
    int64 end_time = 3;               // The end_time of the event, 0 or -1 if the event is opened.
    int64 start_time = 4;             // Start timestamp of the event.
    uint32 duration = 5;              // Duration in seconds.
    uint32 sla_duration = 6;          // The duration of the event in the given timeperiod.
    uint32 timeperiod_id = 7;         // ID of the timeperiod.
    bool timeperiod_is_default = 8;   // True if the timeperiod is the default one for this BA.
}

Dimension BA​

This event is part of the dimension (i.e configuration) dump occurring at startup and after each BAM configuration reload.

BAM::PbDimensionBaEvent​

CategoryelementID
625393241

This event is a Protobuf event, so items are not serialized as in BBDO v2 events, but using the Protobuf 3 serialization mechanism. When BBDO v3 is used, no more BAM::DimensionBaEvent events should be sent. Instead, you should see BAM::PbDimensionBaEvent events.

The protobuf message is the following:

message DimensionBaEvent {
    uint32 ba_id = 1;                   // ID of the BA.
    string ba_name = 2;                 // Name of the BA.
    string ba_description = 3;          // Description of the BA.
    double sla_month_percent_crit = 4;
    double sla_month_percent_warn = 5;
    uint32 sla_duration_crit = 6;
    uint32 sla_duration_warn = 7;
}

Dimension KPI​

This event is part of the dimension (i.e configuration) dump occurring at startup and after each BAM configuration reload.

BAM::PbDimensionKpiEvent​

CategoryelementID
626393242

This event is a Protobuf event, so items are not serialized as in BBDO v2 events, but using the Protobuf 3 serialization mechanism. When BBDO v3 is used, no more BAM::DimensionKpiEvent events should be sent. Instead, you should see BAM::PbDimensionKpiEvent events.

The protobuf message is the following:

message DimensionKpiEvent {
    uint32 kpi_id = 1;               // Id of the KPI.
    uint32 ba_id = 2;                // Id of the parent BA of this KPI.
    string ba_name = 3;              // Name of the parent BA of this KPI.
    uint32 host_id = 4;              // Id of the host associated with this KPI for service KPI.
    string host_name = 5;            // Name of the host associated with this KPI for service KPI.
    uint32 service_id = 6;           // Id of the service associated with this KPI for service KPI.
    string service_description = 7;  // Description of the service associated with this KPI for service KPI.
    uint32 kpi_ba_id = 8;            // Id of the BA associated with this KPI for BA KPI.
    string kpi_ba_name = 9;          // Name of the BA associated with this KPI for BA KPI.
    uint32 meta_service_id = 10;     // Id of the meta-service associated with this KPI for meta-service KPI.
    string meta_service_name = 11;   // Name of the meta-service associated with this KPI for meta-service KPI.
    uint32 boolean_id = 12;          // Id of the boolean expression associated with this KPI for boolean KPI.
    string boolean_name = 13;        // Name of the boolean expression associated with this KPI for boolean KPI.
    double impact_warning = 14;      // Impact of a warning state for this KPI.
    double impact_critical = 15;     // Impact of a critical state for this KPI.
    double impact_unknown = 16;      // Impact of a unknown state for this KPI.
}

Dimension BA BV relation​

This event is part of the dimension (i.e configuration) dump occurring at startup and after each BAM configuration reload.

BAM::PbDimensionBaBvRelationEvent​

CategoryelementID
623393239

This event is a Protobuf event, so items are not serialized as in BBDO v2 events, but using the Protobuf 3 serialization mechanism. When BBDO v3 is used, no more BAM::DimensionBaBvRelationEvent events should be sent. Instead, you should see BAM::PbDimensionBaBvRelationEvent events.

The protobuf message is the following:

message DimensionBaBvRelationEvent {
    uint32 ba_id = 1;       // ID of the BA.
    uint32 bv_id = 2;       // ID of the BV.
}

Dimension BV​

This event is part of the dimension (i.e configuration) dump occurring at startup and after each BAM configuration reload.

BAM::PbDimensionBvEvent​

CategoryelementID
622393238

This event is a Protobuf event, so items are not serialized as in BBDO v2 events, but using the Protobuf 3 serialization mechanism. When BBDO v3 is used, no more BAM::DimensionBvEvent events should be sent. Instead, you should see BAM::PbDimensionBvEvent events.

The protobuf message is the following:

message DimensionBvEvent {
    uint32 bv_id = 1;           // BV ID.
    string bv_name = 2;         // BV name.
    string bv_description = 3;  // BV description.
}

Dimension Truncate Table Signal​

This event is part of the dimension (i.e configuration) dump occurring at startup and after each BAM configuration reload.

This signal is sent before the dump of all the dimensions, and again at the end of the dump.

BAM::PbDimensionTruncateTableSignal​

CategoryelementID
630393246

This event is a Protobuf event, so items are not serialized as in BBDO v2 events, but using the Protobuf 3 serialization mechanism. When BBDO v3 is used, no more BAM::DimensionTruncateTableSignal events should be sent. Instead, you should see BAM::PbDimensionTruncateTableSignal events.

The protobuf message is the following:

message DimensionTruncateTableSignal {
    bool update_started = 1;    // True if this is the start of the dump, false if it's the end.
}

Rebuild signal​

This event is sent when a rebuild of event durations and availabilities is received by the BAM broker endpoint.

BAM::Rebuild​

CategoryelementID
612393228

The content of this message is serialized as follows:

PropertyTypeDescription
bas_to_rebuildstringA string containing the id of all the BAs to rebuild, separated by a comma and a space (i.e "1, 5, 8, 12").

Dimension timeperiod​

This event is part of the dimension (i.e configuration) dump occurring at startup and after each BAM configuration reload.

BAM::PbDimensionTimeperiod​

CategoryelementID
624393240

This event is a Protobuf event, so items are not serialized as in BBDO v2 events, but using the Protobuf 3 serialization mechanism. When BBDO v3 is used, no more BAM::DimensionTimeperiod events should be sent. Instead, you should see BAM::PbDimensionTimeperiod events.

The protobuf message is the following:

message DimensionTimeperiod {
    uint32 id = 1;          // The ID of the timeperiod.
    string name = 2;        // The name of the timeperiod.
    string monday = 3;      // The timeperiod rule for this day.
    string tuesday = 4;     // The timeperiod rule for this day.
    string wednesday = 5;   // The timeperiod rule for this day.
    string thursday = 6;    // The timeperiod rule for this day.
    string friday = 7;      // The timeperiod rule for this day.
    string saturday = 8;    // The timeperiod rule for this day.
    string sunday = 9;      // The timeperiod rule for this day.
}

Dimension BA timeperiod relation​

This event is part of the dimension (i.e configuration) dump occurring at startup and after each BAM configuration reload.

BAM::PbDimensionBaTimeperiodRelation​

CategoryelementID
629393245

This event is a Protobuf event, so items are not serialized as in BBDO v2 events, but using the Protobuf 3 serialization mechanism. When BBDO v3 is used, no more BAM::DimensionBaTimeperiodRelation events should be sent. Instead, you should see BAM::PbDimensionBaTimeperiodRelation events.

The protobuf message is the following:

message DimensionBaTimeperiodRelation {
    uint32 ba_id = 1;           // ID of the BA.
    uint32 timeperiod_id = 2;   // ID of the timeperiod.
    bool is_default = 3;        // True if the timeperiod is the default one for this BA.
}

Inherited downtime​

BAM::PbInheritedDowntime​

CategoryelementID
618393234

This event is a Protobuf event, so items are not serialized as in BBDO v2 events, but using the Protobuf 3 serialization mechanism. When BBDO v3 is used, no more BAM::InheritedDowntime events should be sent. Instead, you should see BAM::PbInheritedDowntime events.

The protobuf message is the following:

message BBDOHeader {
    uint32 conf_version = 1;
}
message InheritedDowntime {
    BBDOHeader header = 1;
    uint32 ba_id = 2;       // ID of the BA concerned by the downtime.
    bool in_downtime = 3;   // True if the BA is in downtime.
}