Examples with DeviceMetricsResult com.vmware.flowgate.openmanage.datamodel.DeviceMetricsResult used on opensource projects

Example 1 with DeviceMetricsResult

use of com.vmware.flowgate.openmanage.datamodel.DeviceMetricsResult in project flowgate by vmware.

the class OpenManageJobService method getMetricsData.

private Map<String, ValueUnit> getMetricsData(String deviceId, OpenManageAPIClient client, Plugin powerManage) {
    DevicePower powerMetricsData = client.getDevicePowerMetrics(deviceId);
    long currentTime = 0;
    Map<String, ValueUnit> metricNameAndValueUnitMap = new HashMap<String, ValueUnit>();
    // Power metrics data from the Openmanage base API
    if (powerMetricsData != null && CIM.equals(powerMetricsData.getDateFormat())) {
        String power = powerMetricsData.getPower();
        if (!NULLVALUE.equals(power)) {
            ValueUnit instantPower = new ValueUnit();
            currentTime = WormholeDateFormat.cimDateToMilliseconds(powerMetricsData.getInstantaneousHeadroomTimeStamp());
            instantPower.setKey(MetricName.SERVER_POWER);
            instantPower.setTime(currentTime);
            instantPower.setUnit(MetricUnit.kW.name());
            instantPower.setValueNum(instantPower.translateUnit(Double.valueOf(power), metricUnitMap.get(powerMetricsData.getPowerUnit()), MetricUnit.kW));
            metricNameAndValueUnitMap.put(MetricName.SERVER_POWER, instantPower);
        }
        long sinceTime = WormholeDateFormat.cimDateToMilliseconds(powerMetricsData.getSince());
        String energyConsumption = powerMetricsData.getSystemEnergyConsumption();
        if (!NULLVALUE.equals(energyConsumption)) {
            long systemEnergyConsumptionTime = WormholeDateFormat.cimDateToMilliseconds(powerMetricsData.getSystemEnergyConsumptionTimeStamp());
            ValueUnit systemEnergyConsumption = new ValueUnit();
            systemEnergyConsumption.setTime(systemEnergyConsumptionTime);
            systemEnergyConsumption.setExtraidentifier(String.valueOf(sinceTime));
            systemEnergyConsumption.setKey(MetricName.SERVER_ENERGY_CONSUMPTION);
            systemEnergyConsumption.setUnit(MetricUnit.kWh.name());
            systemEnergyConsumption.setValueNum(systemEnergyConsumption.translateUnit(Double.valueOf(energyConsumption), metricUnitMap.get(powerMetricsData.getSystemEnergyConsumptionUnit()), MetricUnit.kWh));
            metricNameAndValueUnitMap.put(MetricName.SERVER_ENERGY_CONSUMPTION, systemEnergyConsumption);
        }
        String avgValue = powerMetricsData.getAvgPower();
        if (!NULLVALUE.equals(avgValue)) {
            ValueUnit avgPower = new ValueUnit();
            avgPower.setTime(currentTime);
            avgPower.setExtraidentifier(String.valueOf(sinceTime));
            avgPower.setKey(MetricName.SERVER_AVERAGE_USED_POWER);
            avgPower.setUnit(MetricUnit.kW.name());
            avgPower.setValueNum(avgPower.translateUnit(Double.valueOf(avgValue), metricUnitMap.get(powerMetricsData.getAvgPowerUnit()), MetricUnit.kW));
            metricNameAndValueUnitMap.put(MetricName.SERVER_AVERAGE_USED_POWER, avgPower);
        }
        String peakValue = powerMetricsData.getPeakPower();
        if (!NULLVALUE.equals(peakValue)) {
            ValueUnit peakPower = new ValueUnit();
            peakPower.setTime(currentTime);
            long peakPowerTime = WormholeDateFormat.cimDateToMilliseconds(powerMetricsData.getPeakPowerTimeStamp());
            String sinceAndPeakTime = String.valueOf(sinceTime) + FlowgateConstant.SEPARATOR + String.valueOf(peakPowerTime);
            // Record the since time and peak power time, for example  1612417403074_FIELDSPLIT_1612415606985
            peakPower.setExtraidentifier(sinceAndPeakTime);
            peakPower.setKey(MetricName.SERVER_PEAK_USED_POWER);
            peakPower.setUnit(MetricUnit.kW.name());
            peakPower.setValueNum(peakPower.translateUnit(Double.valueOf(peakValue), metricUnitMap.get(powerMetricsData.getPeakPowerUnit()), MetricUnit.kW));
            metricNameAndValueUnitMap.put(MetricName.SERVER_PEAK_USED_POWER, peakPower);
        }
        String minimumValue = powerMetricsData.getMinimumPower();
        if (!NULLVALUE.equals(minimumValue)) {
            ValueUnit minimumPower = new ValueUnit();
            minimumPower.setTime(currentTime);
            long minimumTime = WormholeDateFormat.cimDateToMilliseconds(powerMetricsData.getMinimumPowerTimeStamp());
            String sinceAndMinimum = String.valueOf(sinceTime) + FlowgateConstant.SEPARATOR + String.valueOf(minimumTime);
            minimumPower.setExtraidentifier(sinceAndMinimum);
            minimumPower.setKey(MetricName.SERVER_MINIMUM_USED_POWER);
            minimumPower.setUnit(MetricUnit.kW.name());
            minimumPower.setValueNum(minimumPower.translateUnit(Double.valueOf(minimumValue), metricUnitMap.get(powerMetricsData.getPeakPowerUnit()), MetricUnit.kW));
            metricNameAndValueUnitMap.put(MetricName.SERVER_MINIMUM_USED_POWER, minimumPower);
        }
    }
    // Temperature metrics data from the Openmanage base API
    DeviceTemperature temperatureMetrics = client.getDeviceTemperatureMetrics(deviceId);
    if (temperatureMetrics != null && CIM.equals(temperatureMetrics.getDateFormat())) {
        String temperatureValue = temperatureMetrics.getInstantaneousTemperature();
        if (!NULLVALUE.equals(temperatureValue)) {
            ValueUnit temperature = new ValueUnit();
            temperature.setKey(MetricName.SERVER_TEMPERATURE);
            temperature.setTime(currentTime);
            temperature.setUnit(MetricUnit.C.name());
            temperature.setValueNum(temperature.translateUnit(Double.valueOf(temperatureValue), metricUnitMap.get(temperatureMetrics.getInstantaneousTemperatureUnit()), MetricUnit.C));
            metricNameAndValueUnitMap.put(MetricName.SERVER_TEMPERATURE, temperature);
        }
        long startTime = WormholeDateFormat.cimDateToMilliseconds(temperatureMetrics.getStartTime());
        String avgValue = temperatureMetrics.getAvgTemperature();
        if (!NULLVALUE.equals(avgValue)) {
            ValueUnit avgTemperature = new ValueUnit();
            avgTemperature.setKey(MetricName.SERVER_AVERAGE_TEMPERATURE);
            avgTemperature.setExtraidentifier(String.valueOf(startTime));
            avgTemperature.setTime(currentTime);
            avgTemperature.setUnit(MetricUnit.C.name());
            avgTemperature.setValueNum(avgTemperature.translateUnit(Double.valueOf(avgValue), metricUnitMap.get(temperatureMetrics.getAvgTemperatureUnit()), MetricUnit.C));
            metricNameAndValueUnitMap.put(MetricName.SERVER_AVERAGE_TEMPERATURE, avgTemperature);
        }
        String peakValue = temperatureMetrics.getPeakTemperature();
        if (!NULLVALUE.equals(peakValue)) {
            ValueUnit peakTemperature = new ValueUnit();
            peakTemperature.setKey(MetricName.SERVER_PEAK_TEMPERATURE);
            long peakTime = WormholeDateFormat.cimDateToMilliseconds(temperatureMetrics.getPeakTemperatureTimeStamp());
            String startAndPeakTime = String.valueOf(startTime) + FlowgateConstant.SEPARATOR + String.valueOf(peakTime);
            peakTemperature.setExtraidentifier(startAndPeakTime);
            peakTemperature.setTime(currentTime);
            peakTemperature.setUnit(MetricUnit.C.name());
            peakTemperature.setValueNum(peakTemperature.translateUnit(Double.valueOf(peakValue), metricUnitMap.get(temperatureMetrics.getPeakTemperatureUnit()), MetricUnit.C));
            metricNameAndValueUnitMap.put(MetricName.SERVER_PEAK_TEMPERATURE, peakTemperature);
        }
    }
    // get metrics form power Manage plugin
    if (powerManage != null && powerManagerEnable) {
        String pluginId = powerManage.getId();
        PowerManageMetricsRequestBody body = new PowerManageMetricsRequestBody();
        body.setPluginId(pluginId);
        body.setEntityType(EntityType.Device.getValue());
        body.setEntityId(Integer.valueOf(deviceId));
        List<Integer> metricTypes = new ArrayList<Integer>();
        metricTypes.add(MetricType.INSTANT_POWER.getValue());
        // Inlet temperature
        metricTypes.add(MetricType.INSTANT_TEMP.getValue());
        body.setMetricTypes(metricTypes);
        body.setDuration(Duration.Recent.getValue());
        body.setSortOrder(SortOrder.Ascending.getValue());
        DeviceMetricsResult metrics = null;
        try {
            metrics = client.getMetricsFromPowerManage(body);
        } catch (HttpClientErrorException e) {
            logger.error("Not found any metrics data.", e);
            return metricNameAndValueUnitMap;
        }
        List<DeviceMetric> metricValues = metrics.getValue();
        if (metricValues.isEmpty()) {
            return metricNameAndValueUnitMap;
        }
        Map<Integer, String> metricTypeMap = new HashMap<Integer, String>();
        metricTypeMap.put(MetricType.INSTANT_POWER.getValue(), MetricName.SERVER_TOTAL_POWER);
        metricTypeMap.put(MetricType.INSTANT_TEMP.getValue(), MetricName.SERVER_FRONT_TEMPERATURE);
        CommonResult<PowerSetting> powerSettings = client.getCommonResult(PowerSetting.class);
        Map<Integer, Integer> powerSettingTypeAndValueMap = new HashMap<Integer, Integer>();
        for (PowerSetting powerSetting : powerSettings.getValue()) {
            powerSettingTypeAndValueMap.put(powerSetting.getId(), powerSetting.getValue());
        }
        for (DeviceMetric metric : metricValues) {
            if (MetricType.INSTANT_POWER.getValue() == metric.getType()) {
                ValueUnit instantPower = new ValueUnit();
                instantPower.setKey(MetricName.SERVER_POWER);
                instantPower.setTime(currentTime);
                instantPower.setUnit(MetricUnit.kW.name());
                int unitValue = powerSettingTypeAndValueMap.get(PowerSettingType.PowerUnit.getValue());
                // PowerUnit1 : watt
                // PowerUnit2 : BtuPerHr
                MetricUnit powerSourceUnit = metricUnitMap.get(PowerSettingType.PowerUnit.name() + unitValue);
                instantPower.setValueNum(instantPower.translateUnit(metric.getValue(), powerSourceUnit, MetricUnit.kW));
                metricNameAndValueUnitMap.put(MetricName.SERVER_POWER, instantPower);
            } else if (MetricType.INSTANT_TEMP.getValue() == metric.getType()) {
                ValueUnit inletTemperature = new ValueUnit();
                inletTemperature.setKey(MetricName.SERVER_FRONT_TEMPERATURE);
                inletTemperature.setTime(currentTime);
                inletTemperature.setUnit(MetricUnit.C.name());
                int unitValue = powerSettingTypeAndValueMap.get(PowerSettingType.TemperatureUnit.getValue());
                MetricUnit temperatureSourceUnit = metricUnitMap.get(PowerSettingType.TemperatureUnit.name() + unitValue);
                inletTemperature.setValueNum(inletTemperature.translateUnit(metric.getValue(), temperatureSourceUnit, MetricUnit.C));
                metricNameAndValueUnitMap.put(MetricName.SERVER_FRONT_TEMPERATURE, inletTemperature);
            }
        }
    }
    return metricNameAndValueUnitMap;
}

Example 2 with DeviceMetricsResult

use of com.vmware.flowgate.openmanage.datamodel.DeviceMetricsResult in project flowgate by vmware.

the class OpenManageAPIClient method getMetricsFromPowerManage.

public DeviceMetricsResult getMetricsFromPowerManage(PowerManageMetricsRequestBody body) {
    DeviceMetricsResult result = null;
    HttpEntity<Object> postEntity = new HttpEntity<Object>(body, buildHeaders());
    ResponseEntity<DeviceMetricsResult> responseEntity = this.restTemplate.exchange(getServiceEndPoint() + GetMetricsUri, HttpMethod.POST, postEntity, DeviceMetricsResult.class);
    if (responseEntity.hasBody()) {
        result = responseEntity.getBody();
    }
    return result;
}

Example 3 with DeviceMetricsResult

use of com.vmware.flowgate.openmanage.datamodel.DeviceMetricsResult in project flowgate by vmware.

the class OpenManageJobTest method getDeviceMetricsResult.

private DeviceMetricsResult getDeviceMetricsResult() {
    DeviceMetricsResult result = new DeviceMetricsResult();
    List<DeviceMetric> values = new ArrayList<DeviceMetric>();
    DeviceMetric power = new DeviceMetric();
    power.setTimestamp("2021-01-02 13:45:05.147666");
    power.setType(MetricType.INSTANT_POWER.getValue());
    power.setValue(70);
    values.add(power);
    DeviceMetric temperature = new DeviceMetric();
    temperature.setType(MetricType.INSTANT_TEMP.getValue());
    temperature.setTimestamp("2021-01-02 13:45:05.147666");
    temperature.setValue(24);
    values.add(temperature);
    result.setValue(values);
    return result;
}