Problems: use problems.get method for fetching triggers, closes #495

src/datasource-zabbix/datasource.ts

@@ -412,39 +412,29 @@ export class ZabbixDatasource {
       tags: { filter: tagsFilter },
     };
 
-    const triggersOptions: any = {
-      showTriggers: showProblems
+    const problemsOptions: any = {
+      recent: showProblems === ShowProblemTypes.Recent,
+      limit: target.options?.limit,
     };
 
     if (showProblems !== ShowProblemTypes.Problems) {
-      triggersOptions.timeFrom = timeFrom;
-      triggersOptions.timeTo = timeTo;
+      problemsOptions.timeFrom = timeFrom;
+      problemsOptions.timeTo = timeTo;
     }
 
     const problemsPromises = Promise.all([
-      this.zabbix.getTriggers(groupFilter, hostFilter, appFilter, triggersOptions, proxyFilter),
+      this.zabbix.getProblems(groupFilter, hostFilter, appFilter, proxyFilter, problemsOptions),
       getProxiesPromise
     ])
-    .then(([triggers, sourceProxies]) => {
+    .then(([problems, sourceProxies]) => {
       proxies = _.keyBy(sourceProxies, 'proxyid');
-      const eventids = _.compact(triggers.map(trigger => {
-        return trigger.lastEvent.eventid;
-      }));
-      return Promise.all([
-        this.zabbix.getExtendedEventData(eventids),
-        Promise.resolve(triggers)
-      ]);
+      return problems;
     })
-    .then(([events, triggers]) => {
-      problemsHandler.addEventTags(events, triggers);
-      problemsHandler.addAcknowledges(events, triggers);
-      return triggers;
-    })
-    .then(triggers => problemsHandler.setMaintenanceStatus(triggers))
-    .then(triggers => problemsHandler.setAckButtonStatus(triggers, showAckButton))
-    .then(triggers => problemsHandler.filterTriggersPre(triggers, replacedTarget))
-    .then(triggers => problemsHandler.addTriggerDataSource(triggers, target))
-    .then(triggers => problemsHandler.addTriggerHostProxy(triggers, proxies));
+    .then(problems => problemsHandler.setMaintenanceStatus(problems))
+    .then(problems => problemsHandler.setAckButtonStatus(problems, showAckButton))
+    .then(problems => problemsHandler.filterTriggersPre(problems, replacedTarget))
+    .then(problems => problemsHandler.addTriggerDataSource(problems, target))
+    .then(problems => problemsHandler.addTriggerHostProxy(problems, proxies));
 
     return problemsPromises.then(problems => {
       const problemsDataFrame = problemsHandler.toDataFrame(problems);
@@ -567,13 +557,13 @@ export class ZabbixDatasource {
       hideHostsInMaintenance: false
     };
 
-    const getTriggers = this.zabbix.getTriggers(this.replaceTemplateVars(annotation.group, {}),
-                                              this.replaceTemplateVars(annotation.host, {}),
-                                              this.replaceTemplateVars(annotation.application, {}),
-                                              triggersOptions);
-
-    return getTriggers.then(triggers => {
+    const groupFilter = this.replaceTemplateVars(annotation.group, {});
+    const hostFilter = this.replaceTemplateVars(annotation.host, {});
+    const appFilter = this.replaceTemplateVars(annotation.application, {});
+    const proxyFilter = undefined;
 
+    return this.zabbix.getProblems(groupFilter, hostFilter, appFilter, proxyFilter, triggersOptions)
+    .then(triggers => {
       // Filter triggers by description
       const triggerName = this.replaceTemplateVars(annotation.trigger, {});
       if (utils.isRegex(triggerName)) {

src/datasource-zabbix/problemsHandler.ts

@@ -4,36 +4,45 @@ import TableModel from 'grafana/app/core/table_model';
 import * as utils from '../datasource-zabbix/utils';
 import * as c from './constants';
 import { DataFrame, Field, FieldType, ArrayVector } from '@grafana/data';
+import { ZBXProblem, ZBXTrigger, ProblemDTO } from './types';
 
-export function addEventTags(events, triggers) {
-  _.each(triggers, trigger => {
-    const event = _.find(events, event => {
-      return event.eventid === trigger.lastEvent.eventid;
-    });
-    if (event && event.tags && event.tags.length) {
-      trigger.tags = event.tags;
-    }
-  });
-  return triggers;
-}
+export function joinTriggersWithProblems(problems: ZBXProblem[], triggers: ZBXTrigger[]): ProblemDTO[] {
+  const problemDTOList: ProblemDTO[] = [];
+  for (let i = 0; i < problems.length; i++) {
+    const p = problems[i];
+    const triggerId = Number(p.objectid);
+    const t = triggers[triggerId];
+    const problemDTO: ProblemDTO = {
+      timestamp: Number(p.clock),
+      triggerid: p.objectid,
+      eventid: p.eventid,
+      name: p.name,
+      severity: p.severity,
+      acknowledged: p.acknowledged,
+      acknowledges: p.acknowledges,
+      tags: p.tags,
+      suppressed: p.suppressed,
+      suppression_data: p.suppression_data,
+      description: t.description,
+      comments: t.comments,
+      value: t.value,
+      groups: t.groups,
+      hosts: t.hosts,
+      items: t.items,
+      alerts: t.alerts,
+      url: t.url,
+      expression: t.expression,
+      correlation_mode: t.correlation_mode,
+      correlation_tag: t.correlation_tag,
+      manual_close: t.manual_close,
+      state: t.state,
+      error: t.error,
+    };
 
-export function addAcknowledges(events, triggers) {
-  // Map events to triggers
-  _.each(triggers, trigger => {
-    const event = _.find(events, event => {
-      return event.eventid === trigger.lastEvent.eventid;
-    });
+    problemDTOList.push(problemDTO);
+  }
 
-    if (event) {
-      trigger.acknowledges = event.acknowledges;
-    }
-
-    if (!trigger.lastEvent.eventid) {
-      trigger.lastEvent = null;
-    }
-  });
-
-  return triggers;
+  return problemDTOList;
 }
 
 export function setMaintenanceStatus(triggers) {
@@ -129,8 +138,6 @@ export function toDataFrame(problems: any[]): DataFrame {
 }
 
 const problemsHandler = {
-  addEventTags,
-  addAcknowledges,
   addTriggerDataSource,
   addTriggerHostProxy,
   setMaintenanceStatus,

src/datasource-zabbix/types.ts

@@ -34,3 +34,172 @@ export enum ShowProblemTypes {
   Recent = 'recent',
   History = 'history',
 }
+
+export interface ProblemDTO {
+  triggerid?: string;
+  eventid?: string;
+  timestamp: number;
+
+  /** Name of the trigger. */
+  name?: string;
+
+  /** Same as a name. */
+  description?: string;
+
+  /** Whether the trigger is in OK or problem state. */
+  value?: string;
+
+  datasource?: string;
+  comments?: string;
+  host?: string;
+  hostTechName?: string;
+  proxy?: string;
+  severity?: string;
+
+  acknowledged?: '1' | '0';
+  acknowledges?: ZBXAcknowledge[];
+
+  groups?: ZBXGroup[];
+  hosts?: ZBXHost[];
+  items?: ZBXItem[];
+  alerts?: ZBXAlert[];
+  tags?: ZBXTag[];
+  url?: string;
+
+  expression?: string;
+  correlation_mode?: string;
+  correlation_tag?: string;
+  suppressed?: string;
+  suppression_data?: any[];
+  state?: string;
+  maintenance?: boolean;
+  manual_close?: string;
+  error?: string;
+
+  showAckButton?: boolean;
+}
+
+export interface ZBXProblem {
+  acknowledged?: '1' | '0';
+  acknowledges?: ZBXAcknowledge[];
+  clock: string;
+  ns: string;
+  correlationid?: string;
+  datasource?: string;
+  name?: string;
+  eventid?: string;
+  maintenance?: boolean;
+  object?: string;
+  objectid?: string;
+  opdata?: any;
+  r_eventid?: string;
+  r_clock?: string;
+  r_ns?: string;
+  severity?: string;
+  showAckButton?: boolean;
+  source?: string;
+  suppressed?: string;
+  suppression_data?: any[];
+  tags?: ZBXTag[];
+  userid?: string;
+}
+
+export interface ZBXTrigger {
+  acknowledges?: ZBXAcknowledge[];
+  showAckButton?: boolean;
+  alerts?: ZBXAlert[];
+  age?: string;
+  color?: string;
+  comments?: string;
+  correlation_mode?: string;
+  correlation_tag?: string;
+  datasource?: string;
+  description?: string;
+  error?: string;
+  expression?: string;
+  flags?: string;
+  groups?: ZBXGroup[];
+  host?: string;
+  hostTechName?: string;
+  hosts?: ZBXHost[];
+  items?: ZBXItem[];
+  lastEvent?: ZBXEvent;
+  lastchange?: string;
+  lastchangeUnix?: number;
+  maintenance?: boolean;
+  manual_close?: string;
+  priority?: string;
+  proxy?: string;
+  recovery_expression?: string;
+  recovery_mode?: string;
+  severity?: string;
+  state?: string;
+  status?: string;
+  tags?: ZBXTag[];
+  templateid?: string;
+  triggerid?: string;
+  /** Whether the trigger can generate multiple problem events. */
+  type?: string;
+  url?: string;
+  value?: string;
+}
+
+export interface ZBXGroup {
+  groupid: string;
+  name: string;
+}
+
+export interface ZBXHost {
+  hostid: string;
+  name: string;
+  host: string;
+  maintenance_status?: string;
+  proxy_hostid?: string;
+}
+
+export interface ZBXItem {
+  itemid: string;
+  name: string;
+  key_: string;
+  lastvalue?: string;
+}
+
+export interface ZBXEvent {
+  eventid: string;
+  clock: string;
+  ns?: string;
+  value?: string;
+  source?: string;
+  object?: string;
+  objectid?: string;
+  acknowledged?: string;
+  severity?: string;
+  hosts?: ZBXHost[];
+  acknowledges?: ZBXAcknowledge[];
+}
+
+export interface ZBXTag {
+  tag: string;
+  value?: string;
+}
+
+export interface ZBXAcknowledge {
+  acknowledgeid: string;
+  eventid: string;
+  userid: string;
+  action: string;
+  clock: string;
+  time: string;
+  message?: string;
+  user: string;
+  alias: string;
+  name: string;
+  surname: string;
+}
+
+export interface ZBXAlert {
+  eventid: string;
+  clock: string;
+  message: string;
+  error: string;
+}

src/datasource-zabbix/zabbix/connectors/zabbix_api/zabbixAPIConnector.ts

@@ -4,7 +4,7 @@ import kbn from 'grafana/app/core/utils/kbn';
 import * as utils from '../../../utils';
 import { ZabbixAPICore } from './zabbixAPICore';
 import { ZBX_ACK_ACTION_NONE, ZBX_ACK_ACTION_ACK, ZBX_ACK_ACTION_ADD_MESSAGE, MIN_SLA_INTERVAL } from '../../../constants';
-import { ShowProblemTypes } from '../../../types';
+import { ShowProblemTypes, ZBXProblem } from '../../../types';
 
 const DEFAULT_ZABBIX_VERSION = '3.0.0';
 
@@ -367,6 +367,62 @@ export class ZabbixAPIConnector {
     return this.request('service.getsla', params);
   }
 
+  getProblems(groupids, hostids, applicationids, options): Promise<ZBXProblem[]> {
+    const { timeFrom, timeTo, recent, severities, limit } = options;
+
+    const params: any = {
+      output: 'extend',
+      selectAcknowledges: 'extend',
+      selectSuppressionData: 'extend',
+      selectTags: 'extend',
+      source: '0',
+      object: '0',
+      sortfield: ['eventid'],
+      sortorder: 'DESC',
+      evaltype: '0',
+      // preservekeys: '1',
+      groupids,
+      hostids,
+      applicationids,
+      recent,
+    };
+
+    if (severities) {
+      params.severities = severities;
+    }
+
+    if (limit) {
+      params.limit = limit;
+    }
+
+    if (timeFrom || timeTo) {
+      params.time_from = timeFrom;
+      params.time_till = timeTo;
+    }
+
+    return this.request('problem.get', params);
+  }
+
+  getTriggersByIds(triggerids: string[]) {
+    const params: any = {
+      output: 'extend',
+      triggerids: triggerids,
+      expandDescription: true,
+      expandData: true,
+      expandComment: true,
+      monitored: true,
+      skipDependent: true,
+      selectGroups: ['name'],
+      selectHosts: ['name', 'host', 'maintenance_status', 'proxy_hostid'],
+      selectItems: ['name', 'key_', 'lastvalue'],
+      // selectLastEvent: 'extend',
+      // selectTags: 'extend',
+      preservekeys: '1',
+    };
+
+    return this.request('trigger.get', params);
+  }
+
   getTriggers(groupids, hostids, applicationids, options) {
     const {showTriggers, maintenance, timeFrom, timeTo} = options;
 

src/datasource-zabbix/zabbix/zabbix.ts

@@ -8,6 +8,7 @@ import { ZabbixAPIConnector } from './connectors/zabbix_api/zabbixAPIConnector';
 import { SQLConnector } from './connectors/sql/sqlConnector';
 import { InfluxDBConnector } from './connectors/influxdb/influxdbConnector';
 import { ZabbixConnector } from './types';
+import { joinTriggersWithProblems } from '../problemsHandler';
 
 const REQUESTS_TO_PROXYFY = [
   'getHistory', 'getTrend', 'getGroups', 'getHosts', 'getApps', 'getItems', 'getMacros', 'getItemsByIDs',
@@ -286,10 +287,7 @@ export class Zabbix implements ZabbixConnector {
     .then(itServices => findByFilter(itServices, itServiceFilter));
   }
 
-  /**
-   * Build query - convert target filters to array of Zabbix items
-   */
-  getTriggers(groupFilter, hostFilter, appFilter, options?, proxyFilter?) {
+  getProblems(groupFilter, hostFilter, appFilter, proxyFilter?, options?) {
     const promises = [
       this.getGroups(groupFilter),
       this.getHosts(groupFilter, hostFilter),
@@ -313,7 +311,13 @@ export class Zabbix implements ZabbixConnector {
 
       return query;
     })
-    .then(query => this.zabbixAPI.getTriggers(query.groupids, query.hostids, query.applicationids, options))
+    // .then(query => this.zabbixAPI.getTriggers(query.groupids, query.hostids, query.applicationids, options))
+    .then(query => this.zabbixAPI.getProblems(query.groupids, query.hostids, query.applicationids, options))
+    .then(problems => {
+      const triggerids = problems?.map(problem => problem.objectid);
+      return Promise.all([Promise.resolve(problems), this.zabbixAPI.getTriggersByIds(triggerids)]);
+    })
+    .then(([problems, triggers]) => joinTriggersWithProblems(problems, triggers))
     .then(triggers => this.filterTriggersByProxy(triggers, proxyFilter))
     .then(triggers => this.expandUserMacro.bind(this)(triggers, true));
   }
@@ -324,14 +328,13 @@ export class Zabbix implements ZabbixConnector {
       if (proxyFilter && proxyFilter !== '/.*/' && triggers) {
         const proxy_ids = proxies.map(proxy => proxy.proxyid);
         triggers = triggers.filter(trigger => {
-          let filtered = false;
           for (let i = 0; i < trigger.hosts.length; i++) {
             const host = trigger.hosts[i];
             if (proxy_ids.includes(host.proxy_hostid)) {
-              filtered = true;
+              return true;
             }
           }
-          return filtered;
+          return false;
         });
       }
       return triggers;