def get_consumed_read_units_percent(table_name, lookback_window_start=15):
""" Returns the number of consumed read units in percent
:type table_name: str
:param table_name: Name of the DynamoDB table
:type lookback_window_start: int
:param lookback_window_start: Relative start time for the CloudWatch metric
:returns: int -- Number of consumed reads
"""
try:
metrics = __get_aws_metric(table_name, lookback_window_start,
'ConsumedReadCapacityUnits')
except BotoServerError:
raise
if metrics:
consumed_read_units = int(
math.ceil(float(metrics[0]['Sum']) / float(300)))
else:
consumed_read_units = 0
try:
consumed_read_units_percent = int(
math.ceil(
float(consumed_read_units) /
float(dynamodb.get_provisioned_table_read_units(table_name)) *
100))
except JSONResponseError:
raise
logger.info('{0} - Consumed read units: {1:d}%'.format(
table_name, consumed_read_units_percent))
return consumed_read_units_percent
def get_consumed_read_units_percent(table_name, time_frame=300):
""" Returns the number of consumed read units in percent
:type table_name: str
:param table_name: Name of the DynamoDB table
:type time_frame: int
:param time_frame: How many seconds to look at
:returns: int -- Number of consumed reads
"""
try:
metrics = __get_aws_metric(
table_name, time_frame, 'ConsumedReadCapacityUnits')
except BotoServerError:
raise
if metrics:
consumed_read_units = int(
math.ceil(float(metrics[0]['Sum'])/float(time_frame)))
else:
consumed_read_units = 0
try:
consumed_read_units_percent = int(
math.ceil(
float(consumed_read_units) /
float(dynamodb.get_provisioned_table_read_units(table_name)) *
100))
except JSONResponseError:
raise
logger.info('{0} - Consumed read units: {1:d}%'.format(
table_name, consumed_read_units_percent))
return consumed_read_units_percent
def get_consumed_read_units_percent(table_name, lookback_window_start=15):
""" Returns the number of consumed read units in percent
:type table_name: str
:param table_name: Name of the DynamoDB table
:type lookback_window_start: int
:param lookback_window_start: Relative start time for the CloudWatch metric
:returns: int -- Number of consumed reads
"""
try:
metrics = __get_aws_metric(
table_name, lookback_window_start, 'ConsumedReadCapacityUnits')
except BotoServerError:
raise
if metrics:
consumed_read_units = int(
math.ceil(float(metrics[0]['Sum'])/float(300)))
else:
consumed_read_units = 0
try:
consumed_read_units_percent = int(
math.ceil(
float(consumed_read_units) /
float(dynamodb.get_provisioned_table_read_units(table_name)) *
100))
except JSONResponseError:
raise
logger.info('{0} - Consumed read units: {1:d}%'.format(
table_name, consumed_read_units_percent))
return consumed_read_units_percent
def get_consumed_read_units_percent(table_name, time_frame=300):
""" Returns the number of consumed read units in percent
:type table_name: str
:param table_name: Name of the DynamoDB table
:type time_frame: int
:param time_frame: How many seconds to look at
:returns: int -- Number of consumed reads
"""
try:
metrics = __get_aws_metric(table_name, time_frame,
'ConsumedReadCapacityUnits')
except BotoServerError:
raise
if metrics:
consumed_read_units = int(
math.ceil(float(metrics[0]['Sum']) / float(time_frame)))
else:
consumed_read_units = 0
try:
consumed_read_units_percent = int(
math.ceil(
float(consumed_read_units) /
float(dynamodb.get_provisioned_table_read_units(table_name)) *
100))
except JSONResponseError:
raise
logger.info('{0} - Consumed read units: {1:d}%'.format(
table_name, consumed_read_units_percent))
return consumed_read_units_percent
def get_throttled_by_provisioned_read_event_percent(table_name,
lookback_window_start=15):
""" Returns the number of throttled read events in percent
:type table_name: str
:param table_name: Name of the DynamoDB table
:type lookback_window_start: int
:param lookback_window_start: Relative start time for the CloudWatch metric
:returns: float -- Percent of throttled read events by provisioning
"""
try:
metrics = __get_aws_metric(table_name, lookback_window_start,
'ReadThrottleEvents')
except BotoServerError:
raise
if metrics:
throttled_read_events = float(metrics[0]['Sum']) / float(300)
else:
throttled_read_events = 0
try:
throttled_by_provisioned_read_percent = (
float(throttled_read_events) /
float(dynamodb.get_provisioned_table_read_units(table_name)) * 100)
except JSONResponseError:
raise
logger.info('{0} - Throttled read percent by provision: {1:.2f}%'.format(
table_name, throttled_by_provisioned_read_percent))
return throttled_by_provisioned_read_percent
def get_throttled_by_provisioned_read_event_percent(table_name, lookback_window_start=15):
""" Returns the number of throttled read events in percent
:type table_name: str
:param table_name: Name of the DynamoDB table
:type lookback_window_start: int
:param lookback_window_start: Relative start time for the CloudWatch metric
:returns: float -- Percent of throttled read events by provisioning
"""
try:
metrics = __get_aws_metric(
table_name, lookback_window_start, 'ReadThrottleEvents')
except BotoServerError:
raise
if metrics:
throttled_read_events = float(metrics[0]['Sum'])/float(300)
else:
throttled_read_events = 0
try: throttled_by_provisioned_read_percent = (float(throttled_read_events) /
float(dynamodb.get_provisioned_table_read_units(table_name)) *
100)
except JSONResponseError:
raise
logger.info('{0} - Throttled read percent by provision: {1:.2f}%'.format(
table_name, throttled_by_provisioned_read_percent))
return throttled_by_provisioned_read_percent
def __update_throughput(table_name, key_name, read_units, write_units):
""" Update throughput on the DynamoDB table
:type table_name: str
:param table_name: Name of the DynamoDB table
:type key_name: str
:param key_name: Configuration option key name
:type read_units: int
:param read_units: New read unit provisioning
:type write_units: int
:param write_units: New write unit provisioning
"""
try:
current_ru = dynamodb.get_provisioned_table_read_units(table_name)
current_wu = dynamodb.get_provisioned_table_write_units(table_name)
except JSONResponseError:
raise
# Check table status
try:
table_status = dynamodb.get_table_status(table_name)
except JSONResponseError:
raise
logger.debug('{0} - Table status is {1}'.format(table_name, table_status))
if table_status != 'ACTIVE':
logger.warning(
'{0} - Not performing throughput changes when table '
'is {1}'.format(table_name, table_status))
return
# If this setting is True, we will only scale down when
# BOTH reads AND writes are low
if get_table_option(key_name, 'always_decrease_rw_together'):
read_units, write_units = __calculate_always_decrease_rw_values(
table_name,
read_units,
current_ru,
write_units,
current_wu)
if read_units == current_ru and write_units == current_wu:
logger.info('{0} - No changes to perform'.format(table_name))
return
dynamodb.update_table_provisioning(
table_name,
key_name,
int(read_units),
int(write_units))
def __update_throughput(table_name, key_name, read_units, write_units):
""" Update throughput on the DynamoDB table
:type table_name: str
:param table_name: Name of the DynamoDB table
:type key_name: str
:param key_name: Configuration option key name
:type read_units: int
:param read_units: New read unit provisioning
:type write_units: int
:param write_units: New write unit provisioning
"""
try:
current_ru = dynamodb.get_provisioned_table_read_units(table_name)
current_wu = dynamodb.get_provisioned_table_write_units(table_name)
except JSONResponseError:
raise
# Check table status
try:
table_status = dynamodb.get_table_status(table_name)
except JSONResponseError:
raise
logger.debug('{0} - Table status is {1}'.format(table_name, table_status))
if table_status != 'ACTIVE':
logger.warning(
'{0} - Not performing throughput changes when table '
'is {1}'.format(table_name, table_status))
return
# If this setting is True, we will only scale down when
# BOTH reads AND writes are low
if get_table_option(key_name, 'always_decrease_rw_together'):
read_units, write_units = __calculate_always_decrease_rw_values(
table_name,
read_units,
current_ru,
write_units,
current_wu)
if read_units == current_ru and write_units == current_wu:
logger.info('{0} - No changes to perform'.format(table_name))
return
dynamodb.update_table_provisioning(
table_name,
key_name,
int(read_units),
int(write_units))
def get_consumed_read_units_percent(
table_name, lookback_window_start=15, lookback_period=5):
""" Returns the number of consumed read units in percent
:type table_name: str
:param table_name: Name of the DynamoDB table
:type lookback_window_start: int
:param lookback_window_start: Relative start time for the CloudWatch metric
:type lookback_period: int
:param lookback_period: Number of minutes to look at
:returns: float -- Number of consumed reads as a
percentage of provisioned reads
"""
try:
metrics = __get_aws_metric(
table_name,
lookback_window_start,
lookback_period,
'ConsumedReadCapacityUnits')
except BotoServerError:
raise
if metrics:
lookback_seconds = lookback_period * 60
consumed_read_units = (
float(metrics[0]['Sum']) / float(lookback_seconds))
else:
consumed_read_units = 0
try:
table_read_units = dynamodb.get_provisioned_table_read_units(
table_name)
consumed_read_units_percent = (
float(consumed_read_units) /
float(table_read_units) * 100)
except JSONResponseError:
raise
logger.info('{0} - Consumed read units: {1:.2f}%'.format(
table_name, consumed_read_units_percent))
return consumed_read_units_percent
def __ensure_provisioning_reads(table_name, key_name, num_consec_read_checks):
""" Ensure that provisioning is correct
:type table_name: str
:param table_name: Name of the DynamoDB table
:type key_name: str
:param key_name: Configuration option key name
:type num_consec_read_checks: int
:param num_consec_read_checks: How many consecutive checks have we had
:returns: (bool, int, int)
update_needed, updated_read_units, num_consec_read_checks
"""
if not get_table_option(key_name, 'enable_reads_autoscaling'):
logger.info(
'{0} - Autoscaling of reads has been disabled'.format(table_name))
return False, dynamodb.get_provisioned_table_read_units(table_name), 0
update_needed = False
try:
lookback_window_start = get_table_option(key_name,
'lookback_window_start')
lookback_period = get_table_option(key_name, 'lookback_period')
current_read_units = dynamodb.get_provisioned_table_read_units(
table_name)
consumed_read_units_percent = \
table_stats.get_consumed_read_units_percent(
table_name, lookback_window_start, lookback_period)
throttled_read_count = \
table_stats.get_throttled_read_event_count(
table_name, lookback_window_start, lookback_period)
throttled_by_provisioned_read_percent = \
table_stats.get_throttled_by_provisioned_read_event_percent(
table_name, lookback_window_start, lookback_period)
throttled_by_consumed_read_percent = \
table_stats.get_throttled_by_consumed_read_percent(
table_name, lookback_window_start, lookback_period)
reads_upper_threshold = \
get_table_option(key_name, 'reads_upper_threshold')
reads_lower_threshold = \
get_table_option(key_name, 'reads_lower_threshold')
throttled_reads_upper_threshold = \
get_table_option(key_name, 'throttled_reads_upper_threshold')
increase_reads_with = \
get_table_option(key_name, 'increase_reads_with')
increase_reads_unit = \
get_table_option(key_name, 'increase_reads_unit')
decrease_reads_with = \
get_table_option(key_name, 'decrease_reads_with')
decrease_reads_unit = \
get_table_option(key_name, 'decrease_reads_unit')
min_provisioned_reads = \
get_table_option(key_name, 'min_provisioned_reads')
max_provisioned_reads = \
get_table_option(key_name, 'max_provisioned_reads')
num_read_checks_before_scale_down = \
get_table_option(key_name, 'num_read_checks_before_scale_down')
num_read_checks_reset_percent = \
get_table_option(key_name, 'num_read_checks_reset_percent')
increase_throttled_by_provisioned_reads_unit = \
get_table_option(
key_name, 'increase_throttled_by_provisioned_reads_unit')
increase_throttled_by_provisioned_reads_scale = \
get_table_option(
key_name, 'increase_throttled_by_provisioned_reads_scale')
increase_throttled_by_consumed_reads_unit = \
get_table_option(
key_name, 'increase_throttled_by_consumed_reads_unit')
increase_throttled_by_consumed_reads_scale = \
get_table_option(
key_name, 'increase_throttled_by_consumed_reads_scale')
increase_consumed_reads_unit = \
get_table_option(key_name, 'increase_consumed_reads_unit')
increase_consumed_reads_with = \
get_table_option(key_name, 'increase_consumed_reads_with')
increase_consumed_reads_scale = \
get_table_option(key_name, 'increase_consumed_reads_scale')
decrease_consumed_reads_unit = \
get_table_option(key_name, 'decrease_consumed_reads_unit')
decrease_consumed_reads_with = \
get_table_option(key_name, 'decrease_consumed_reads_with')
decrease_consumed_reads_scale = \
get_table_option(key_name, 'decrease_consumed_reads_scale')
except JSONResponseError:
raise
except BotoServerError:
raise
# Set the updated units to the current read unit value
updated_read_units = current_read_units
# Reset consecutive reads if num_read_checks_reset_percent is reached
if num_read_checks_reset_percent:
if consumed_read_units_percent >= num_read_checks_reset_percent:
logger.info('{0} - Resetting the number of consecutive '
'read checks. Reason: Consumed percent {1} is '
'greater than reset percent: {2}'.format(
table_name, consumed_read_units_percent,
num_read_checks_reset_percent))
num_consec_read_checks = 0
# Exit if up scaling has been disabled
if not get_table_option(key_name, 'enable_reads_up_scaling'):
logger.debug(
'{0} - Up scaling event detected. No action taken as scaling '
'up reads has been disabled in the configuration'.format(
table_name))
else:
# If local/granular values not specified use global values
increase_consumed_reads_unit = \
increase_consumed_reads_unit or increase_reads_unit
increase_throttled_by_provisioned_reads_unit = \
increase_throttled_by_provisioned_reads_unit or increase_reads_unit
increase_throttled_by_consumed_reads_unit = \
increase_throttled_by_consumed_reads_unit or increase_reads_unit
increase_consumed_reads_with = \
increase_consumed_reads_with or increase_reads_with
# Initialise variables to store calculated provisioning
throttled_by_provisioned_calculated_provisioning = scale_reader(
increase_throttled_by_provisioned_reads_scale,
throttled_by_provisioned_read_percent)
throttled_by_consumed_calculated_provisioning = scale_reader(
increase_throttled_by_consumed_reads_scale,
throttled_by_consumed_read_percent)
consumed_calculated_provisioning = scale_reader(
increase_consumed_reads_scale, consumed_read_units_percent)
throttled_count_calculated_provisioning = 0
calculated_provisioning = 0
# Increase needed due to high throttled to provisioned ratio
if throttled_by_provisioned_calculated_provisioning:
if increase_throttled_by_provisioned_reads_unit == 'percent':
throttled_by_provisioned_calculated_provisioning = \
calculators.increase_reads_in_percent(
current_read_units,
throttled_by_provisioned_calculated_provisioning,
get_table_option(key_name, 'max_provisioned_reads'),
consumed_read_units_percent,
table_name)
else:
throttled_by_provisioned_calculated_provisioning = \
calculators.increase_reads_in_units(
current_read_units,
throttled_by_provisioned_calculated_provisioning,
get_table_option(key_name, 'max_provisioned_reads'),
consumed_read_units_percent,
table_name)
# Increase needed due to high throttled to consumed ratio
if throttled_by_consumed_calculated_provisioning:
if increase_throttled_by_consumed_reads_unit == 'percent':
throttled_by_consumed_calculated_provisioning = \
calculators.increase_reads_in_percent(
current_read_units,
throttled_by_consumed_calculated_provisioning,
get_table_option(key_name, 'max_provisioned_reads'),
consumed_read_units_percent,
table_name)
else:
throttled_by_consumed_calculated_provisioning = \
calculators.increase_reads_in_units(
current_read_units,
throttled_by_consumed_calculated_provisioning,
get_table_option(key_name, 'max_provisioned_reads'),
consumed_read_units_percent,
table_name)
# Increase needed due to high CU consumption
if consumed_calculated_provisioning:
if increase_consumed_reads_unit == 'percent':
consumed_calculated_provisioning = \
calculators.increase_reads_in_percent(
current_read_units,
consumed_calculated_provisioning,
get_table_option(key_name, 'max_provisioned_reads'),
consumed_read_units_percent,
table_name)
else:
consumed_calculated_provisioning = \
calculators.increase_reads_in_units(
current_read_units,
consumed_calculated_provisioning,
get_table_option(key_name, 'max_provisioned_reads'),
consumed_read_units_percent,
table_name)
elif (reads_upper_threshold
and consumed_read_units_percent > reads_upper_threshold
and not increase_consumed_reads_scale):
if increase_consumed_reads_unit == 'percent':
consumed_calculated_provisioning = \
calculators.increase_reads_in_percent(
current_read_units,
increase_consumed_reads_with,
get_table_option(key_name, 'max_provisioned_reads'),
consumed_read_units_percent,
table_name)
else:
consumed_calculated_provisioning = \
calculators.increase_reads_in_units(
current_read_units,
increase_consumed_reads_with,
get_table_option(key_name, 'max_provisioned_reads'),
consumed_read_units_percent,
table_name)
# Increase needed due to high throttling
if (throttled_reads_upper_threshold
and throttled_read_count > throttled_reads_upper_threshold):
if increase_reads_unit == 'percent':
throttled_count_calculated_provisioning = \
calculators.increase_reads_in_percent(
updated_read_units,
increase_consumed_reads_with,
get_table_option(key_name, 'max_provisioned_reads'),
consumed_read_units_percent,
table_name)
else:
throttled_count_calculated_provisioning = \
calculators.increase_reads_in_units(
updated_read_units,
increase_reads_with,
get_table_option(key_name, 'max_provisioned_reads'),
consumed_read_units_percent,
table_name)
# Determine which metric requires the most scaling
if (throttled_by_provisioned_calculated_provisioning >
calculated_provisioning):
calculated_provisioning = \
throttled_by_provisioned_calculated_provisioning
scale_reason = ("due to throttled events by provisioned "
"units threshold being exceeded")
if (throttled_by_consumed_calculated_provisioning >
calculated_provisioning):
calculated_provisioning = \
throttled_by_consumed_calculated_provisioning
scale_reason = ("due to throttled events by consumed "
"units threshold being exceeded")
if consumed_calculated_provisioning > calculated_provisioning:
calculated_provisioning = consumed_calculated_provisioning
scale_reason = "due to consumed threshold being exceeded"
if throttled_count_calculated_provisioning > calculated_provisioning:
calculated_provisioning = throttled_count_calculated_provisioning
scale_reason = "due to throttled events threshold being exceeded"
if calculated_provisioning > current_read_units:
logger.info('{0} - Resetting the number of consecutive '
'read checks. Reason: scale up {1}'.format(
table_name, scale_reason))
num_consec_read_checks = 0
update_needed = True
updated_read_units = calculated_provisioning
# Decrease needed due to low CU consumption
if not update_needed:
# If local/granular values not specified use global values
decrease_consumed_reads_unit = \
decrease_consumed_reads_unit or decrease_reads_unit
decrease_consumed_reads_with = \
decrease_consumed_reads_with or decrease_reads_with
# Initialise variables to store calculated provisioning
consumed_calculated_provisioning = scale_reader_decrease(
decrease_consumed_reads_scale, consumed_read_units_percent)
calculated_provisioning = None
# Exit if down scaling has been disabled
if not get_table_option(key_name, 'enable_reads_down_scaling'):
logger.debug(
'{0} - Down scaling event detected. No action taken as scaling'
' down reads has been disabled in the configuration'.format(
table_name))
# Exit if reads == 0% and downscaling has been disabled at 0%
elif (consumed_read_units_percent == 0 and not get_table_option(
key_name, 'allow_scaling_down_reads_on_0_percent')):
logger.info(
'{0} - Down scaling event detected. No action taken as scaling'
' down reads is not done when usage is at 0%'.format(
table_name))
else:
if consumed_calculated_provisioning:
if decrease_consumed_reads_unit == 'percent':
calculated_provisioning = \
calculators.decrease_reads_in_percent(
updated_read_units,
consumed_calculated_provisioning,
get_table_option(
key_name, 'min_provisioned_reads'),
table_name)
else:
calculated_provisioning = \
calculators.decrease_reads_in_units(
updated_read_units,
consumed_calculated_provisioning,
get_table_option(
key_name, 'min_provisioned_reads'),
table_name)
elif (reads_lower_threshold
and consumed_read_units_percent < reads_lower_threshold
and not decrease_consumed_reads_scale):
if decrease_consumed_reads_unit == 'percent':
calculated_provisioning = \
calculators.decrease_reads_in_percent(
updated_read_units,
decrease_consumed_reads_with,
get_table_option(
key_name, 'min_provisioned_reads'),
table_name)
else:
calculated_provisioning = \
calculators.decrease_reads_in_units(
updated_read_units,
decrease_consumed_reads_with,
get_table_option(
key_name, 'min_provisioned_reads'),
table_name)
if (calculated_provisioning
and current_read_units != calculated_provisioning):
num_consec_read_checks += 1
if num_consec_read_checks >= num_read_checks_before_scale_down:
update_needed = True
updated_read_units = calculated_provisioning
# Never go over the configured max provisioning
if max_provisioned_reads:
if int(updated_read_units) > int(max_provisioned_reads):
update_needed = True
updated_read_units = int(max_provisioned_reads)
logger.info('Will not increase writes over max-provisioned-reads '
'limit ({0} writes)'.format(updated_read_units))
# Ensure that we have met the min-provisioning
if min_provisioned_reads:
if int(min_provisioned_reads) > int(updated_read_units):
update_needed = True
updated_read_units = int(min_provisioned_reads)
logger.info('{0} - Increasing reads to meet min-provisioned-reads '
'limit ({1} reads)'.format(table_name,
updated_read_units))
if calculators.is_consumed_over_proposed(current_read_units,
updated_read_units,
consumed_read_units_percent):
update_needed = False
updated_read_units = current_read_units
logger.info(
'{0} - Consumed is over proposed read units. Will leave table at '
'current setting.'.format(table_name))
logger.info('{0} - Consecutive read checks {1}/{2}'.format(
table_name, num_consec_read_checks, num_read_checks_before_scale_down))
return update_needed, updated_read_units, num_consec_read_checks
def __ensure_provisioning_reads(table_name, key_name, num_consec_read_checks):
""" Ensure that provisioning is correct
:type table_name: str
:param table_name: Name of the DynamoDB table
:type key_name: str
:param key_name: Configuration option key name
:type num_consec_read_checks: int
:param num_consec_read_checks: How many consecutive checks have we had
:returns: (bool, int, int)
update_needed, updated_read_units, num_consec_read_checks
"""
if not get_table_option(key_name, 'enable_reads_autoscaling'):
logger.info(
'{0} - Autoscaling of reads has been disabled'.format(table_name))
return False, dynamodb.get_provisioned_table_read_units(table_name), 0
update_needed = False
try:
lookback_window_start = get_table_option(
key_name, 'lookback_window_start')
lookback_period = get_table_option(key_name, 'lookback_period')
current_read_units = dynamodb.get_provisioned_table_read_units(
table_name)
consumed_read_units_percent = \
table_stats.get_consumed_read_units_percent(
table_name, lookback_window_start, lookback_period)
throttled_read_count = \
table_stats.get_throttled_read_event_count(
table_name, lookback_window_start, lookback_period)
throttled_by_provisioned_read_percent = \
table_stats.get_throttled_by_provisioned_read_event_percent(
table_name, lookback_window_start, lookback_period)
throttled_by_consumed_read_percent = \
table_stats.get_throttled_by_consumed_read_percent(
table_name, lookback_window_start, lookback_period)
reads_upper_threshold = \
get_table_option(key_name, 'reads_upper_threshold')
reads_lower_threshold = \
get_table_option(key_name, 'reads_lower_threshold')
throttled_reads_upper_threshold = \
get_table_option(key_name, 'throttled_reads_upper_threshold')
increase_reads_with = \
get_table_option(key_name, 'increase_reads_with')
increase_reads_unit = \
get_table_option(key_name, 'increase_reads_unit')
decrease_reads_with = \
get_table_option(key_name, 'decrease_reads_with')
decrease_reads_unit = \
get_table_option(key_name, 'decrease_reads_unit')
min_provisioned_reads = \
get_table_option(key_name, 'min_provisioned_reads')
max_provisioned_reads = \
get_table_option(key_name, 'max_provisioned_reads')
num_read_checks_before_scale_down = \
get_table_option(key_name, 'num_read_checks_before_scale_down')
num_read_checks_reset_percent = \
get_table_option(key_name, 'num_read_checks_reset_percent')
increase_throttled_by_provisioned_reads_unit = \
get_table_option(
key_name, 'increase_throttled_by_provisioned_reads_unit')
increase_throttled_by_provisioned_reads_scale = \
get_table_option(
key_name, 'increase_throttled_by_provisioned_reads_scale')
increase_throttled_by_consumed_reads_unit = \
get_table_option(
key_name, 'increase_throttled_by_consumed_reads_unit')
increase_throttled_by_consumed_reads_scale = \
get_table_option(
key_name, 'increase_throttled_by_consumed_reads_scale')
increase_consumed_reads_unit = \
get_table_option(key_name, 'increase_consumed_reads_unit')
increase_consumed_reads_with = \
get_table_option(key_name, 'increase_consumed_reads_with')
increase_consumed_reads_scale = \
get_table_option(key_name, 'increase_consumed_reads_scale')
decrease_consumed_reads_unit = \
get_table_option(key_name, 'decrease_consumed_reads_unit')
decrease_consumed_reads_with = \
get_table_option(key_name, 'decrease_consumed_reads_with')
decrease_consumed_reads_scale = \
get_table_option(key_name, 'decrease_consumed_reads_scale')
except JSONResponseError:
raise
except BotoServerError:
raise
# Set the updated units to the current read unit value
updated_read_units = current_read_units
# Reset consecutive reads if num_read_checks_reset_percent is reached
if num_read_checks_reset_percent:
if consumed_read_units_percent >= num_read_checks_reset_percent:
logger.info(
'{0} - Resetting the number of consecutive '
'read checks. Reason: Consumed percent {1} is '
'greater than reset percent: {2}'.format(
table_name,
consumed_read_units_percent,
num_read_checks_reset_percent))
num_consec_read_checks = 0
# Exit if up scaling has been disabled
if not get_table_option(key_name, 'enable_reads_up_scaling'):
logger.debug(
'{0} - Up scaling event detected. No action taken as scaling '
'up reads has been disabled in the configuration'.format(
table_name))
else:
# If local/granular values not specified use global values
increase_consumed_reads_unit = \
increase_consumed_reads_unit or increase_reads_unit
increase_throttled_by_provisioned_reads_unit = \
increase_throttled_by_provisioned_reads_unit or increase_reads_unit
increase_throttled_by_consumed_reads_unit = \
increase_throttled_by_consumed_reads_unit or increase_reads_unit
increase_consumed_reads_with = \
increase_consumed_reads_with or increase_reads_with
# Initialise variables to store calculated provisioning
throttled_by_provisioned_calculated_provisioning = scale_reader(
increase_throttled_by_provisioned_reads_scale,
throttled_by_provisioned_read_percent)
throttled_by_consumed_calculated_provisioning = scale_reader(
increase_throttled_by_consumed_reads_scale,
throttled_by_consumed_read_percent)
consumed_calculated_provisioning = scale_reader(
increase_consumed_reads_scale,
consumed_read_units_percent)
throttled_count_calculated_provisioning = 0
calculated_provisioning = 0
# Increase needed due to high throttled to provisioned ratio
if throttled_by_provisioned_calculated_provisioning:
if increase_throttled_by_provisioned_reads_unit == 'percent':
throttled_by_provisioned_calculated_provisioning = \
calculators.increase_reads_in_percent(
current_read_units,
throttled_by_provisioned_calculated_provisioning,
get_table_option(key_name, 'max_provisioned_reads'),
consumed_read_units_percent,
table_name)
else:
throttled_by_provisioned_calculated_provisioning = \
calculators.increase_reads_in_units(
current_read_units,
throttled_by_provisioned_calculated_provisioning,
get_table_option(key_name, 'max_provisioned_reads'),
consumed_read_units_percent,
table_name)
# Increase needed due to high throttled to consumed ratio
if throttled_by_consumed_calculated_provisioning:
if increase_throttled_by_consumed_reads_unit == 'percent':
throttled_by_consumed_calculated_provisioning = \
calculators.increase_reads_in_percent(
current_read_units,
throttled_by_consumed_calculated_provisioning,
get_table_option(key_name, 'max_provisioned_reads'),
consumed_read_units_percent,
table_name)
else:
throttled_by_consumed_calculated_provisioning = \
calculators.increase_reads_in_units(
current_read_units,
throttled_by_consumed_calculated_provisioning,
get_table_option(key_name, 'max_provisioned_reads'),
consumed_read_units_percent,
table_name)
# Increase needed due to high CU consumption
if consumed_calculated_provisioning:
if increase_consumed_reads_unit == 'percent':
consumed_calculated_provisioning = \
calculators.increase_reads_in_percent(
current_read_units,
consumed_calculated_provisioning,
get_table_option(key_name, 'max_provisioned_reads'),
consumed_read_units_percent,
table_name)
else:
consumed_calculated_provisioning = \
calculators.increase_reads_in_units(
current_read_units,
consumed_calculated_provisioning,
get_table_option(key_name, 'max_provisioned_reads'),
consumed_read_units_percent,
table_name)
elif (reads_upper_threshold
and consumed_read_units_percent > reads_upper_threshold
and not increase_consumed_reads_scale):
if increase_consumed_reads_unit == 'percent':
consumed_calculated_provisioning = \
calculators.increase_reads_in_percent(
current_read_units,
increase_consumed_reads_with,
get_table_option(key_name, 'max_provisioned_reads'),
consumed_read_units_percent,
table_name)
else:
consumed_calculated_provisioning = \
calculators.increase_reads_in_units(
current_read_units,
increase_consumed_reads_with,
get_table_option(key_name, 'max_provisioned_reads'),
consumed_read_units_percent,
table_name)
# Increase needed due to high throttling
if (throttled_reads_upper_threshold
and throttled_read_count > throttled_reads_upper_threshold):
if increase_reads_unit == 'percent':
throttled_count_calculated_provisioning = \
calculators.increase_reads_in_percent(
updated_read_units,
increase_consumed_reads_with,
get_table_option(key_name, 'max_provisioned_reads'),
consumed_read_units_percent,
table_name)
else:
throttled_count_calculated_provisioning = \
calculators.increase_reads_in_units(
updated_read_units,
increase_reads_with,
get_table_option(key_name, 'max_provisioned_reads'),
consumed_read_units_percent,
table_name)
# Determine which metric requires the most scaling
if (throttled_by_provisioned_calculated_provisioning
> calculated_provisioning):
calculated_provisioning = \
throttled_by_provisioned_calculated_provisioning
scale_reason = (
"due to throttled events by provisioned "
"units threshold being exceeded")
if (throttled_by_consumed_calculated_provisioning
> calculated_provisioning):
calculated_provisioning = \
throttled_by_consumed_calculated_provisioning
scale_reason = (
"due to throttled events by consumed "
"units threshold being exceeded")
if consumed_calculated_provisioning > calculated_provisioning:
calculated_provisioning = consumed_calculated_provisioning
scale_reason = "due to consumed threshold being exceeded"
if throttled_count_calculated_provisioning > calculated_provisioning:
calculated_provisioning = throttled_count_calculated_provisioning
scale_reason = "due to throttled events threshold being exceeded"
if calculated_provisioning > current_read_units:
logger.info(
'{0} - Resetting the number of consecutive '
'read checks. Reason: scale up {1}'.format(
table_name, scale_reason))
num_consec_read_checks = 0
update_needed = True
updated_read_units = calculated_provisioning
# Decrease needed due to low CU consumption
if not update_needed:
# If local/granular values not specified use global values
decrease_consumed_reads_unit = \
decrease_consumed_reads_unit or decrease_reads_unit
decrease_consumed_reads_with = \
decrease_consumed_reads_with or decrease_reads_with
# Initialise variables to store calculated provisioning
consumed_calculated_provisioning = scale_reader_decrease(
decrease_consumed_reads_scale,
consumed_read_units_percent)
calculated_provisioning = None
# Exit if down scaling has been disabled
if not get_table_option(key_name, 'enable_reads_down_scaling'):
logger.debug(
'{0} - Down scaling event detected. No action taken as scaling'
' down reads has been disabled in the configuration'.format(
table_name))
# Exit if reads == 0% and downscaling has been disabled at 0%
elif (consumed_read_units_percent == 0 and not
get_table_option(
key_name, 'allow_scaling_down_reads_on_0_percent')):
logger.info(
'{0} - Down scaling event detected. No action taken as scaling'
' down reads is not done when usage is at 0%'.format(
table_name))
else:
if consumed_calculated_provisioning:
if decrease_consumed_reads_unit == 'percent':
calculated_provisioning = \
calculators.decrease_reads_in_percent(
updated_read_units,
consumed_calculated_provisioning,
get_table_option(
key_name, 'min_provisioned_reads'),
table_name)
else:
calculated_provisioning = \
calculators.decrease_reads_in_units(
updated_read_units,
consumed_calculated_provisioning,
get_table_option(
key_name, 'min_provisioned_reads'),
table_name)
elif (reads_lower_threshold
and consumed_read_units_percent < reads_lower_threshold
and not decrease_consumed_reads_scale):
if decrease_consumed_reads_unit == 'percent':
calculated_provisioning = \
calculators.decrease_reads_in_percent(
updated_read_units,
decrease_consumed_reads_with,
get_table_option(
key_name, 'min_provisioned_reads'),
table_name)
else:
calculated_provisioning = \
calculators.decrease_reads_in_units(
updated_read_units,
decrease_consumed_reads_with,
get_table_option(
key_name, 'min_provisioned_reads'),
table_name)
if (calculated_provisioning
and current_read_units != calculated_provisioning):
num_consec_read_checks += 1
if num_consec_read_checks >= num_read_checks_before_scale_down:
update_needed = True
updated_read_units = calculated_provisioning
# Never go over the configured max provisioning
if max_provisioned_reads:
if int(updated_read_units) > int(max_provisioned_reads):
update_needed = True
updated_read_units = int(max_provisioned_reads)
logger.info(
'Will not increase writes over max-provisioned-reads '
'limit ({0} writes)'.format(updated_read_units))
# Ensure that we have met the min-provisioning
if min_provisioned_reads:
if int(min_provisioned_reads) > int(updated_read_units):
update_needed = True
updated_read_units = int(min_provisioned_reads)
logger.info(
'{0} - Increasing reads to meet min-provisioned-reads '
'limit ({1} reads)'.format(table_name, updated_read_units))
if calculators.is_consumed_over_proposed(
current_read_units,
updated_read_units,
consumed_read_units_percent):
update_needed = False
updated_read_units = current_read_units
logger.info(
'{0} - Consumed is over proposed read units. Will leave table at '
'current setting.'.format(table_name))
logger.info('{0} - Consecutive read checks {1}/{2}'.format(
table_name,
num_consec_read_checks,
num_read_checks_before_scale_down))
return update_needed, updated_read_units, num_consec_read_checks
def __ensure_provisioning_reads(table_name, key_name, num_consec_read_checks):
""" Ensure that provisioning is correct
:type table_name: str
:param table_name: Name of the DynamoDB table
:type key_name: str
:param key_name: Configuration option key name
:type num_consec_read_checks: int
:param num_consec_read_checks: How many consecutive checks have we had
:returns: (bool, int, int)
update_needed, updated_read_units, num_consec_read_checks
"""
if not get_table_option(key_name, 'enable_reads_autoscaling'):
logger.info(
'{0} - Autoscaling of reads has been disabled'.format(table_name))
return False, dynamodb.get_provisioned_table_read_units(table_name), 0
update_needed = False
try:
lookback_window_start = get_table_option(key_name,
'lookback_window_start')
current_read_units = dynamodb.get_provisioned_table_read_units(
table_name)
consumed_read_units_percent = \
table_stats.get_consumed_read_units_percent(
table_name, lookback_window_start)
throttled_read_count = \
table_stats.get_throttled_read_event_count(
table_name, lookback_window_start)
reads_upper_threshold = \
get_table_option(key_name, 'reads_upper_threshold')
reads_lower_threshold = \
get_table_option(key_name, 'reads_lower_threshold')
throttled_reads_upper_threshold = \
get_table_option(key_name, 'throttled_reads_upper_threshold')
increase_reads_with = \
get_table_option(key_name, 'increase_reads_with')
increase_reads_unit = \
get_table_option(key_name, 'increase_reads_unit')
decrease_reads_with = \
get_table_option(key_name, 'decrease_reads_with')
decrease_reads_unit = \
get_table_option(key_name, 'decrease_reads_unit')
min_provisioned_reads = \
get_table_option(key_name, 'min_provisioned_reads')
max_provisioned_reads = \
get_table_option(key_name, 'max_provisioned_reads')
num_read_checks_before_scale_down = \
get_table_option(key_name, 'num_read_checks_before_scale_down')
num_read_checks_reset_percent = \
get_table_option(key_name, 'num_read_checks_reset_percent')
except JSONResponseError:
raise
except BotoServerError:
raise
# Set the updated units to the current read unit value
updated_read_units = current_read_units
# Reset consecutive reads if num_read_checks_reset_percent is reached
if num_read_checks_reset_percent:
if consumed_read_units_percent >= num_read_checks_reset_percent:
logger.info('{0} - Resetting the number of consecutive '
'read checks. Reason: Consumed percent {1} is '
'greater than reset percent: {2}'.format(
table_name, consumed_read_units_percent,
num_read_checks_reset_percent))
num_consec_read_checks = 0
if (consumed_read_units_percent == 0 and not get_table_option(
key_name, 'allow_scaling_down_reads_on_0_percent')):
logger.info(
'{0} - Scaling down reads is not done when usage is at 0%'.format(
table_name))
# Increase needed due to high CU consumption
elif consumed_read_units_percent >= reads_upper_threshold:
# Exit if up scaling has been disabled
if not get_table_option(key_name, 'enable_reads_up_scaling'):
logger.debug(
'{0} - Up scaling event detected. No action taken as scaling '
'up reads has been disabled in the configuration'.format(
table_name))
else:
if increase_reads_unit == 'percent':
calculated_provisioning = calculators.increase_reads_in_percent(
current_read_units, increase_reads_with,
get_table_option(key_name, 'max_provisioned_reads'),
consumed_read_units_percent, table_name)
else:
calculated_provisioning = calculators.increase_reads_in_units(
current_read_units, increase_reads_with,
get_table_option(key_name, 'max_provisioned_reads'),
consumed_read_units_percent, table_name)
if current_read_units != calculated_provisioning:
logger.info(
'{0} - Resetting the number of consecutive '
'read checks. Reason: scale up event detected'.format(
table_name))
num_consec_read_checks = 0
update_needed = True
updated_read_units = calculated_provisioning
# Increase needed due to high throttling
elif throttled_read_count > throttled_reads_upper_threshold:
if throttled_reads_upper_threshold > 0:
if increase_reads_unit == 'percent':
calculated_provisioning = calculators.increase_reads_in_percent(
updated_read_units, increase_reads_with,
get_table_option(key_name, 'max_provisioned_reads'),
consumed_read_units_percent, table_name)
else:
calculated_provisioning = calculators.increase_reads_in_units(
updated_read_units, increase_reads_with,
get_table_option(key_name, 'max_provisioned_reads'),
consumed_read_units_percent, table_name)
if current_read_units != calculated_provisioning:
logger.info(
'{0} - Resetting the number of consecutive '
'read checks. Reason: scale up event detected'.format(
table_name))
num_consec_read_checks = 0
update_needed = True
updated_read_units = calculated_provisioning
# Decrease needed due to low CU consumption
elif consumed_read_units_percent <= reads_lower_threshold:
# Exit if down scaling has been disabled
if not get_table_option(key_name, 'enable_reads_down_scaling'):
logger.debug(
'{0} - Down scaling event detected. No action taken as scaling'
'down reads has been disabled in the configuration'.format(
table_name))
else:
if decrease_reads_unit == 'percent':
calculated_provisioning = calculators.decrease_reads_in_percent(
updated_read_units, decrease_reads_with,
get_table_option(key_name, 'min_provisioned_reads'),
table_name)
else:
calculated_provisioning = calculators.decrease_reads_in_units(
updated_read_units, decrease_reads_with,
get_table_option(key_name, 'min_provisioned_reads'),
table_name)
if current_read_units != calculated_provisioning:
num_consec_read_checks = num_consec_read_checks + 1
if num_consec_read_checks >= num_read_checks_before_scale_down:
update_needed = True
updated_read_units = calculated_provisioning
# Never go over the configured max provisioning
if max_provisioned_reads:
if int(updated_read_units) > int(max_provisioned_reads):
update_needed = True
updated_read_units = int(max_provisioned_reads)
logger.info('Will not increase writes over max-provisioned-reads '
'limit ({0} writes)'.format(updated_read_units))
# Ensure that we have met the min-provisioning
if min_provisioned_reads:
if int(min_provisioned_reads) > int(updated_read_units):
update_needed = True
updated_read_units = int(min_provisioned_reads)
logger.info('{0} - Increasing reads to meet min-provisioned-reads '
'limit ({1} reads)'.format(table_name,
updated_read_units))
logger.info('{0} - Consecutive read checks {1}/{2}'.format(
table_name, num_consec_read_checks, num_read_checks_before_scale_down))
return update_needed, updated_read_units, num_consec_read_checks
def __ensure_provisioning_reads(table_name, key_name, num_consec_read_checks):
""" Ensure that provisioning is correct
:type table_name: str
:param table_name: Name of the DynamoDB table
:type key_name: str
:param key_name: Configuration option key name
:type num_consec_read_checks: int
:param num_consec_read_checks: How many consecutive checks have we had
:returns: (bool, int, int)
update_needed, updated_read_units, num_consec_read_checks
"""
if not get_table_option(key_name, 'enable_reads_autoscaling'):
logger.info(
'{0} - Autoscaling of reads has been disabled'.format(table_name))
return False, dynamodb.get_provisioned_table_read_units(table_name), 0
update_needed = False
try:
lookback_window_start = get_table_option(
key_name, 'lookback_window_start')
current_read_units = dynamodb.get_provisioned_table_read_units(
table_name)
consumed_read_units_percent = \
table_stats.get_consumed_read_units_percent(
table_name, lookback_window_start)
throttled_read_count = \
table_stats.get_throttled_read_event_count(
table_name, lookback_window_start)
reads_upper_threshold = \
get_table_option(key_name, 'reads_upper_threshold')
reads_lower_threshold = \
get_table_option(key_name, 'reads_lower_threshold')
throttled_reads_upper_threshold = \
get_table_option(key_name, 'throttled_reads_upper_threshold')
increase_reads_with = \
get_table_option(key_name, 'increase_reads_with')
increase_reads_unit = \
get_table_option(key_name, 'increase_reads_unit')
decrease_reads_with = \
get_table_option(key_name, 'decrease_reads_with')
decrease_reads_unit = \
get_table_option(key_name, 'decrease_reads_unit')
min_provisioned_reads = \
get_table_option(key_name, 'min_provisioned_reads')
max_provisioned_reads = \
get_table_option(key_name, 'max_provisioned_reads')
num_read_checks_before_scale_down = \
get_table_option(key_name, 'num_read_checks_before_scale_down')
num_read_checks_reset_percent = \
get_table_option(key_name, 'num_read_checks_reset_percent')
except JSONResponseError:
raise
except BotoServerError:
raise
# Set the updated units to the current read unit value
updated_read_units = current_read_units
# Reset consecutive reads if num_read_checks_reset_percent is reached
if num_read_checks_reset_percent:
if consumed_read_units_percent >= num_read_checks_reset_percent:
logger.info(
'{0} - Resetting the number of consecutive '
'read checks. Reason: Consumed percent {1} is '
'greater than reset percent: {2}'.format(
table_name,
consumed_read_units_percent,
num_read_checks_reset_percent))
num_consec_read_checks = 0
if (consumed_read_units_percent == 0 and not
get_table_option(
key_name, 'allow_scaling_down_reads_on_0_percent')):
logger.info(
'{0} - Scaling down reads is not done when usage is at 0%'.format(
table_name))
# Increase needed due to high CU consumption
elif consumed_read_units_percent >= reads_upper_threshold:
# Exit if up scaling has been disabled
if not get_table_option(key_name, 'enable_reads_up_scaling'):
logger.debug(
'{0} - Up scaling event detected. No action taken as scaling '
'up reads has been disabled in the configuration'.format(
table_name))
else:
if increase_reads_unit == 'percent':
calculated_provisioning = calculators.increase_reads_in_percent(
current_read_units,
increase_reads_with,
get_table_option(key_name, 'max_provisioned_reads'),
consumed_read_units_percent,
table_name)
else:
calculated_provisioning = calculators.increase_reads_in_units(
current_read_units,
increase_reads_with,
get_table_option(key_name, 'max_provisioned_reads'),
consumed_read_units_percent,
table_name)
if current_read_units != calculated_provisioning:
logger.info(
'{0} - Resetting the number of consecutive '
'read checks. Reason: scale up event detected'.format(
table_name))
num_consec_read_checks = 0
update_needed = True
updated_read_units = calculated_provisioning
# Increase needed due to high throttling
elif throttled_read_count > throttled_reads_upper_threshold:
if throttled_reads_upper_threshold > 0:
if increase_reads_unit == 'percent':
calculated_provisioning = calculators.increase_reads_in_percent(
updated_read_units,
increase_reads_with,
get_table_option(key_name, 'max_provisioned_reads'),
consumed_read_units_percent,
table_name)
else:
calculated_provisioning = calculators.increase_reads_in_units(
updated_read_units,
increase_reads_with,
get_table_option(key_name, 'max_provisioned_reads'),
consumed_read_units_percent,
table_name)
if current_read_units != calculated_provisioning:
logger.info(
'{0} - Resetting the number of consecutive '
'read checks. Reason: scale up event detected'.format(
table_name))
num_consec_read_checks = 0
update_needed = True
updated_read_units = calculated_provisioning
# Decrease needed due to low CU consumption
elif consumed_read_units_percent <= reads_lower_threshold:
# Exit if down scaling has been disabled
if not get_table_option(key_name, 'enable_reads_down_scaling'):
logger.debug(
'{0} - Down scaling event detected. No action taken as scaling'
'down reads has been disabled in the configuration'.format(
table_name))
else:
if decrease_reads_unit == 'percent':
calculated_provisioning = calculators.decrease_reads_in_percent(
updated_read_units,
decrease_reads_with,
get_table_option(key_name, 'min_provisioned_reads'),
table_name)
else:
calculated_provisioning = calculators.decrease_reads_in_units(
updated_read_units,
decrease_reads_with,
get_table_option(key_name, 'min_provisioned_reads'),
table_name)
if current_read_units != calculated_provisioning:
num_consec_read_checks = num_consec_read_checks + 1
if num_consec_read_checks >= num_read_checks_before_scale_down:
update_needed = True
updated_read_units = calculated_provisioning
# Never go over the configured max provisioning
if max_provisioned_reads:
if int(updated_read_units) > int(max_provisioned_reads):
update_needed = True
updated_read_units = int(max_provisioned_reads)
logger.info(
'Will not increase writes over max-provisioned-reads '
'limit ({0} writes)'.format(updated_read_units))
# Ensure that we have met the min-provisioning
if min_provisioned_reads:
if int(min_provisioned_reads) > int(updated_read_units):
update_needed = True
updated_read_units = int(min_provisioned_reads)
logger.info(
'{0} - Increasing reads to meet min-provisioned-reads '
'limit ({1} reads)'.format(table_name, updated_read_units))
logger.info('{0} - Consecutive read checks {1}/{2}'.format(
table_name,
num_consec_read_checks,
num_read_checks_before_scale_down))
return update_needed, updated_read_units, num_consec_read_checks
def __ensure_provisioning_reads(table_name, key_name):
""" Ensure that provisioning is correct
:type table_name: str
:param table_name: Name of the DynamoDB table
:type key_name: str
:param key_name: Configuration option key name
:returns: (bool, int) -- update_needed, updated_read_units
"""
if not get_table_option(key_name, 'enable_reads_autoscaling'):
logger.info(
'{0} - Autoscaling of reads has been disabled'.format(table_name))
return False, dynamodb.get_provisioned_table_read_units(table_name)
update_needed = False
try:
updated_read_units = dynamodb.get_provisioned_table_read_units(
table_name)
consumed_read_units_percent = \
table_stats.get_consumed_read_units_percent(table_name)
throttled_read_count = \
table_stats.get_throttled_read_event_count(table_name)
reads_upper_threshold = \
get_table_option(key_name, 'reads_upper_threshold')
reads_lower_threshold = \
get_table_option(key_name, 'reads_lower_threshold')
throttled_reads_upper_threshold = \
get_table_option(key_name, 'throttled_reads_upper_threshold')
increase_reads_with = \
get_table_option(key_name, 'increase_reads_with')
increase_reads_unit = \
get_table_option(key_name, 'increase_reads_unit')
decrease_reads_with = \
get_table_option(key_name, 'decrease_reads_with')
decrease_reads_unit = \
get_table_option(key_name, 'decrease_reads_unit')
max_provisioned_reads = \
get_table_option(key_name, 'max_provisioned_reads')
except JSONResponseError:
raise
except BotoServerError:
raise
if (consumed_read_units_percent == 0 and not
get_table_option(
key_name, 'allow_scaling_down_reads_on_0_percent')):
print('1')
logger.info(
'{0} - Scaling down reads is not done when usage is at 0%'.format(
table_name))
elif consumed_read_units_percent >= reads_upper_threshold:
if increase_reads_unit == 'percent':
updated_provisioning = calculators.increase_reads_in_percent(
updated_read_units,
increase_reads_with,
get_table_option(key_name, 'max_provisioned_reads'),
table_name)
else:
updated_provisioning = calculators.increase_reads_in_units(
updated_read_units,
increase_reads_with,
get_table_option(key_name, 'max_provisioned_reads'),
table_name)
if updated_read_units != updated_provisioning:
update_needed = True
updated_read_units = updated_provisioning
elif throttled_read_count > throttled_reads_upper_threshold:
if throttled_reads_upper_threshold > 0:
if increase_reads_unit == 'percent':
updated_provisioning = calculators.increase_reads_in_percent(
updated_read_units,
increase_reads_with,
get_table_option(key_name, 'max_provisioned_reads'),
table_name)
else:
updated_provisioning = calculators.increase_reads_in_units(
updated_read_units,
increase_reads_with,
get_table_option(key_name, 'max_provisioned_reads'),
table_name)
if updated_read_units != updated_provisioning:
update_needed = True
updated_read_units = updated_provisioning
elif consumed_read_units_percent <= reads_lower_threshold:
if decrease_reads_unit == 'percent':
updated_provisioning = calculators.decrease_reads_in_percent(
updated_read_units,
decrease_reads_with,
get_table_option(key_name, 'min_provisioned_reads'),
table_name)
else:
updated_provisioning = calculators.decrease_reads_in_units(
updated_read_units,
decrease_reads_with,
get_table_option(key_name, 'min_provisioned_reads'),
table_name)
if updated_read_units != updated_provisioning:
update_needed = True
updated_read_units = updated_provisioning
if max_provisioned_reads:
if (int(updated_read_units) > int(max_provisioned_reads)):
update_needed = True
updated_read_units = int(max_provisioned_reads)
logger.info(
'Will not increase writes over max-provisioned-reads '
'limit ({0} writes)'.format(updated_read_units))
return update_needed, int(updated_read_units)
