Performance

This section gives examples of the following performance functionality:

• Registering an Array For Performance Data Collection

• Diagnostic Metrics Gathering

• Real-Time Metrics Gathering

• Backup Performance Database

• Thresholds

Registering an Array For Performance Data Collection

Arrays can be enabled for both diagnostic and real-time performance data collection using PyU4V. The example below demonstrates enabling both varieties and confirming the registration has been successful.

"""docs/source/programmers_guide_src/code/performance-registration.py"""

import PyU4V

# Initialise PyU4V Unisphere connection
conn = PyU4V.U4VConn()

# Check if the primary array is registered for diagnostic performance data
# collection
if not conn.performance.is_array_diagnostic_performance_registered():
    # If not, enable diagnostic data collection
    conn.performance.enable_diagnostic_data_collection()
    # Confirm the enable operation was successful
    assert conn.performance.is_array_diagnostic_performance_registered()

# Check if the primary array is registered for real-time performance data
# collection
if not conn.performance.is_array_real_time_performance_registered():
    # If not, enable real-time data collection
    conn.performance.enable_real_time_data_collection()
    # Confirm the enable operation was successful
    assert conn.performance.is_array_real_time_performance_registered()

# Close the session
conn.close_session()

Diagnostic Metrics Gathering

This example demonstrates a range of diagnostics (5 minute interval) performance functionality such as getting performance categories and metrics, timestamps from Unisphere for an array, get recent only performance information, and getting ResponseTime for all SRPs in an array.

"""docs/source/programmers_guide_src/code/performance-diagnostic_calls.py"""

import PyU4V

# Initialise PyU4V Unisphere connection
conn = PyU4V.U4VConn()

# Get a list of performance categories
category_list = conn.performance.get_performance_categories_list()

# Get a list of supported metrics for the category 'FEDirector'
fe_dir_metrics = conn.performance.get_performance_metrics_list(
    category='FEDirector')

# Get a list of KPI only metrics for the category 'StorageGroup'
storage_group_metrics = conn.performance.get_performance_metrics_list(
    category='StorageGroup', kpi_only=True)

# Get array KPI performance metrics for the most recent timestamp only, set
# recency so timestamp has to be less than 5 minutes old
array_performance_data = conn.performance.get_array_stats(metrics='KPI',
                                                          recency=5)

# Get ResponseTime for each SRP for the last 4 hours
# Firstly get the most recent performance timestamp for your array
recent_timestamp = conn.performance.get_last_available_timestamp()
# Set the performance recency value to 10 minutes and check if the most
# recent timestamp meets that recency value
conn.performance.recency = 10
is_recent_ten = conn.performance.is_timestamp_current(recent_timestamp)
# Recency can also be passed to is_timestamp_current
is_recent_five = conn.performance.is_timestamp_current(recent_timestamp,
                                                       minutes=5)

# Get the start and end times by providing the most recent timestamp and
# specifying a 4 hour difference
start_time, end_time = conn.performance.get_timestamp_by_hour(
    end_time=recent_timestamp, hours_difference=4)
# Get the list of SRPs
srp_keys = conn.performance.get_storage_resource_pool_keys()
srp_list = list()
for key in srp_keys:
    srp_list.append(key.get('srpId'))
# Get the performance data for each of the SRPs in the list
for srp in srp_list:
    srp_data = conn.performance.get_storage_resource_pool_stats(
        srp_id=srp, metrics='ResponseTime', start_time=start_time,
        end_time=end_time)

# Close the session
conn.close_session()

Real-Time Metrics Gathering

With the PyU4V 9.2 release it is possible to retrieve real-time performance data from Unisphere for arrays which have been registered for real-time data. This example demonstrates getting supported real-time peformance metrics for a given category, getting the keys for that category (the assets which we can obtain real-time data for), and retrieving real-time data for the last hour.

Note

The maximum amount of real-time data that can be retrieved from Unisphere via PyU4V in one call is one hour. If more than one hour of data is required then more calls can be run, however if you find yourself doing this often it is a good idea to save data locally for easy retrieval and reduce the amount of REST calls required.

Note

Storage Groups are supported for real-time metrics but these must be enabled in Unisphere via Settings > Performance > System Registrations. Under the table heading Storage Group Real Time and for the array you want to enable real-time for, select the option Real Time Storage Groups and add up to 100 Storage Groups for real-time data collection.

"""docs/source/programmers_guide_src/code/performance-real_time_calls.py"""

import random
import time

import PyU4V

# Initialise PyU4V Unisphere connection
conn = PyU4V.U4VConn()

# Get a list of real-time performance categories
category_list = conn.performance.real_time.get_categories()

# Get the first and last available timestamps for my primary array
array_timestamps = conn.performance.real_time.get_timestamps(
    array_id=conn.array_id)
# Get the first and last available timestamps for all registered arrays
all_timestamps = conn.performance.real_time.get_timestamps()

# Get storage groups enabled for real-time data on primary array
rt_sg_list = conn.performance.real_time.get_storage_group_keys()
# Get the real-time metrics for storage groups
rt_sg_metrics = conn.performance.real_time.get_storage_group_metrics()

# Get the current time in milliseconds since epoch
current_time = int(time.time()) * 1000
# Set the start time as one hour previous to current time, one hour is the
# maximum amount of data that can be retrieved in one call for real-time
start_time = current_time - (60 * 60 * 1000)

# Get real-time storage group data for a random group and random selection of
# metrics
sg_metrics = random.choices(rt_sg_metrics, k=5)
sg_name = random.choice(rt_sg_list)

# Retrieve the performance data from Unisphere
rt_sg_data = conn.performance.real_time.get_storage_group_stats(
    start_date=start_time, end_date=current_time, metrics=sg_metrics,
    instance_id=sg_name)

# Close the session
conn.close_session()

Backup Performance Database

Backup of a performance database is a recommended practice. The backup performance database option is available for one or more storage systems, regardless of their registration status.

By default, only Trending & Planning (Historical) data is backed up. The performance databases backups should be stored in a safe location. Performance database backups can be restored. For more information on restoring backups please see Unisphere for PowerMax official documentation, for now only performing backups is supported via REST.

To create a backup of a performance data simply call performance.backup_performance_database(), both the array_id and filename are optional values, if no filename is provided then the client hostname will be used.

Note

Underscores will be stripped from any filename provided, this is due to Unisphere restricting the length of the filename string when underscores are provided. The backup filename format will be as follows when viewed in Unisphere: {array_id}_{date}{time}_{TZ}_{filename}_SPABackup.dat

"""docs/source/programmers_guide_src/code/performance-db_backup.py"""

import PyU4V

# Initialise PyU4V connection to Unisphere
conn = PyU4V.U4VConn()

# Backup the performance database
conn.performance.backup_performance_database(
    array_id=conn.array_id, filename='PyU4V_Example')

# Close the session
conn.close_session()

To view this performance database backup in Unisphere navigate to Settings > Unisphere Databases > Performance Databases. Use the performance databases list view to view and manage databases.

Thresholds

In this example both performance threshold calls and CSV file handling with PyU4V are demonstrated. A call is made to retrieve a full list of performance threshold settings and output the results to a CSV file at a path specified by the user. That CSV file is read into a Python dictionary and the respective values within are updated. Once complete the updated threshold settings are uploaded to Unisphere to take immediate effect.

"""docs/source/programmers_guide_src/code/performance-thresholds.py."""

import os
import PyU4V

# Initialise PyU4V connection to Unisphere
conn = PyU4V.U4VConn()

# Set the CSV file name and path
current_directory = os.getcwd()
output_csv_name = 'thresholds-test.csv'
output_csv_path = os.path.join(current_directory, output_csv_name)

# Generate a CSV file with all of the thresholds and corresponding values
conn.performance.generate_threshold_settings_csv(
    output_csv_path=output_csv_path)

# Read the CSV values into a dictionary, cast all string booleans and
# numbers to their proper types
threshold_dict = PyU4V.utils.file_handler.read_csv_values(output_csv_path,
                                                          convert=True)

# Increase all of the first threshold values by 5 and second threshold
# values by 10, alert only on the KPIs
for i in range(0, len(threshold_dict.get('metric'))):
    threshold_dict['firstThreshold'][i] += 5
    threshold_dict['secondThreshold'][i] += 5
    if threshold_dict['kpi'][i] is True:
        threshold_dict['alertError'][i] = True

# Process the CSV file and update the thresholds with their corresponding
# values, we are only going to set the threshold value if it is a KPI
conn.performance.set_thresholds_from_csv(csv_file_path=output_csv_path,
                                         kpi_only=True)

# It is also possible to set a threshold value without editing the values
# in a CSV, the threshold metric and be edited directly
threshold_settings = conn.performance.update_threshold_settings(
    category='Array', metric='PercentCacheWP', first_threshold=60,
    first_threshold_occurrences=2, first_threshold_samples=6,
    first_threshold_severity='INFORMATION', second_threshold=90,
    second_threshold_occurrences=1, second_threshold_samples=3,
    second_threshold_severity='CRITICAL', alert=True)

# Close the session
conn.close_session()