awslabs.elasticache-mcp-server 0.1.1__py3-none-any.whl

awslabs/elasticache_mcp_server/tools/cc/delete.py

@@ -0,0 +1,65 @@
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Delete cache cluster tool for ElastiCache MCP server."""
+
+from ...common.connection import ElastiCacheConnectionManager
+from ...common.decorators import handle_exceptions
+from ...common.server import mcp
+from ...context import Context
+from typing import Optional
+
+
+@mcp.tool(name='delete-cache-cluster')
+@handle_exceptions
+async def delete_cache_cluster(
+    cache_cluster_id: str,
+    final_snapshot_identifier: Optional[str] = None,
+) -> dict:
+    """Delete an Amazon ElastiCache cache cluster.
+
+    This tool deletes an existing cache cluster. Optionally, it can create a final
+    snapshot of the cluster before deletion.
+
+    Parameters:
+        cache_cluster_id (str): The ID of the cache cluster to delete.
+        final_snapshot_identifier (Optional[str]): The user-supplied name of a final
+            cache cluster snapshot. This is the unique name that identifies the
+            snapshot. ElastiCache creates the snapshot, and then deletes the cache
+            cluster immediately afterward.
+
+    Returns:
+        Dict containing information about the deleted cache cluster.
+    """
+    # Check if readonly mode is enabled
+    if Context.readonly_mode():
+        raise ValueError(
+            'You have configured this tool in readonly mode. To make this change you will have to update your configuration.'
+        )
+
+    # Get ElastiCache client
+    elasticache_client = ElastiCacheConnectionManager.get_connection()
+
+    # Build delete request
+    delete_request = {
+        'CacheClusterId': cache_cluster_id,
+    }
+
+    # Add optional final snapshot if provided
+    if final_snapshot_identifier:
+        delete_request['FinalSnapshotIdentifier'] = final_snapshot_identifier
+
+    # Delete the cache cluster
+    response = elasticache_client.delete_cache_cluster(**delete_request)
+    return response

awslabs/elasticache_mcp_server/tools/cc/describe.py

@@ -0,0 +1,80 @@
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Describe cache clusters tool for ElastiCache MCP server."""
+
+from ...common.connection import ElastiCacheConnectionManager
+from ...common.decorators import handle_exceptions
+from ...common.server import mcp
+from typing import Dict, Optional
+
+
+@mcp.tool(name='describe-cache-clusters')
+@handle_exceptions
+async def describe_cache_clusters(
+    cache_cluster_id: Optional[str] = None,
+    max_records: Optional[int] = None,
+    marker: Optional[str] = None,
+    show_cache_node_info: Optional[bool] = None,
+    show_cache_clusters_not_in_replication_groups: Optional[bool] = None,
+) -> Dict:
+    """Describe one or more ElastiCache cache clusters.
+
+    This tool returns information about provisioned cache clusters. If a cache cluster ID
+    is specified, information about only that cache cluster is returned. Otherwise, information
+    about up to MaxRecords cache clusters is returned.
+
+    Parameters:
+        cache_cluster_id (Optional[str]): The identifier for the cache cluster to describe.
+            If not provided, information about all cache clusters is returned.
+        max_records (Optional[int]): The maximum number of records to include in the response.
+            If more records exist than the specified MaxRecords value, a marker is included
+            in the response so that the remaining results can be retrieved.
+        marker (Optional[str]): An optional marker returned from a previous request. Use this marker
+            for pagination of results from this operation. If this parameter is specified,
+            the response includes only records beyond the marker, up to the value specified
+            by MaxRecords.
+        show_cache_node_info (Optional[bool]): Whether to include detailed information about
+            cache nodes in the response.
+        show_cache_clusters_not_in_replication_groups (Optional[bool]): Whether to show only
+            cache clusters that are not members of a replication group.
+
+    Returns:
+        Dict containing information about the cache cluster(s), including:
+        - CacheClusters: List of cache clusters
+        - Marker: Pagination marker for next set of results
+    """
+    # Get ElastiCache client
+    elasticache_client = ElastiCacheConnectionManager.get_connection()
+
+    # Build describe request
+    describe_request = {}
+
+    # Add optional parameters if provided
+    if cache_cluster_id:
+        describe_request['CacheClusterId'] = cache_cluster_id
+    if max_records:
+        describe_request['MaxRecords'] = max_records
+    if marker:
+        describe_request['Marker'] = marker
+    if show_cache_node_info is not None:
+        describe_request['ShowCacheNodeInfo'] = show_cache_node_info
+    if show_cache_clusters_not_in_replication_groups is not None:
+        describe_request['ShowCacheClustersNotInReplicationGroups'] = (
+            show_cache_clusters_not_in_replication_groups
+        )
+
+    # Describe the cache cluster(s)
+    response = elasticache_client.describe_cache_clusters(**describe_request)
+    return response

awslabs/elasticache_mcp_server/tools/cc/modify.py

@@ -0,0 +1,159 @@
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Modify cache cluster tool for ElastiCache MCP server."""
+
+from ...common.connection import ElastiCacheConnectionManager
+from ...common.decorators import handle_exceptions
+from ...common.server import mcp
+from ...context import Context
+from ..rg.processors import process_log_delivery_configurations
+from .processors import process_scale_config
+from pydantic import BaseModel, ConfigDict, Field
+from typing import Any, Dict, List, Optional, Union
+
+
+class ModifyCacheClusterRequest(BaseModel):
+    """Request model for modifying an ElastiCache cache cluster."""
+
+    model_config = ConfigDict(validate_by_name=True, arbitrary_types_allowed=True)
+
+    cache_cluster_id: str = Field(..., description='The cache cluster to modify')
+    num_cache_nodes: Optional[int] = Field(None, description='The new number of cache nodes')
+    cache_node_ids_to_remove: Optional[List[str]] = Field(
+        None, description='Cache node IDs to remove when scaling down'
+    )
+    az_mode: Optional[str] = Field(
+        None,
+        description='Specifies whether nodes in this Memcached cluster are created in a single AZ or multiple AZs',
+    )
+    new_availability_zones: Optional[List[str]] = Field(
+        None, description='List of Availability Zones to use when modifying AZ mode'
+    )
+    cache_security_group_names: Optional[List[str]] = Field(
+        None, description='List of cache security group names to associate'
+    )
+    security_group_ids: Optional[List[str]] = Field(
+        None, description='List of Amazon VPC security group IDs'
+    )
+    preferred_maintenance_window: Optional[str] = Field(
+        None, description='The weekly time range for maintenance'
+    )
+    notification_topic_arn: Optional[str] = Field(
+        None, description='The ARN of an SNS topic for notifications'
+    )
+    cache_parameter_group_name: Optional[str] = Field(
+        None, description='The name of the cache parameter group to apply'
+    )
+    notification_topic_status: Optional[str] = Field(
+        None, description='The status of the SNS notification topic'
+    )
+    apply_immediately: Optional[bool] = Field(
+        None, description='Whether to apply changes immediately or during maintenance window'
+    )
+    engine_version: Optional[str] = Field(
+        None, description='The upgraded version of the cache engine'
+    )
+    auto_minor_version_upgrade: Optional[bool] = Field(
+        None, description='Enable/disable automatic minor version upgrades'
+    )
+    snapshot_retention_limit: Optional[int] = Field(
+        None, description='The number of days to retain backups'
+    )
+    snapshot_window: Optional[str] = Field(None, description='The daily time range for backups')
+    cache_node_type: Optional[str] = Field(
+        None, description='The new compute and memory capacity of the nodes'
+    )
+    auth_token: Optional[str] = Field(
+        None, description='The password used to access a password protected server'
+    )
+    auth_token_update_strategy: Optional[str] = Field(
+        None, description="Strategy to use when updating auth token ('SET', 'ROTATE', 'DELETE')"
+    )
+    log_delivery_configurations: Optional[Union[str, List[Dict]]] = Field(
+        None, description='Log delivery configurations'
+    )
+    scale_config: Optional[Union[str, Dict]] = Field(None, description='Scale configuration')
+
+
+@mcp.tool(name='modify-cache-cluster')
+@handle_exceptions
+async def modify_cache_cluster(request: ModifyCacheClusterRequest) -> Dict:
+    """Modify an existing Amazon ElastiCache cache cluster."""
+    # Check if readonly mode is enabled
+    if Context.readonly_mode():
+        raise ValueError(
+            'You have configured this tool in readonly mode. To make this change you will have to update your configuration.'
+        )
+
+    # Get ElastiCache client
+    elasticache_client = ElastiCacheConnectionManager.get_connection()
+
+    # Convert request model to dictionary, only including non-None values
+    modify_request: Dict[str, Any] = {'CacheClusterId': request.cache_cluster_id}
+
+    if request.num_cache_nodes is not None:
+        modify_request['NumCacheNodes'] = request.num_cache_nodes
+    if request.cache_node_ids_to_remove:
+        modify_request['CacheNodeIdsToRemove'] = request.cache_node_ids_to_remove
+    if request.az_mode:
+        modify_request['AZMode'] = request.az_mode
+    if request.new_availability_zones:
+        modify_request['NewAvailabilityZones'] = request.new_availability_zones
+    if request.cache_security_group_names:
+        modify_request['CacheSecurityGroupNames'] = request.cache_security_group_names
+    if request.security_group_ids:
+        modify_request['SecurityGroupIds'] = request.security_group_ids
+    if request.preferred_maintenance_window:
+        modify_request['PreferredMaintenanceWindow'] = request.preferred_maintenance_window
+    if request.notification_topic_arn:
+        modify_request['NotificationTopicArn'] = request.notification_topic_arn
+    if request.cache_parameter_group_name:
+        modify_request['CacheParameterGroupName'] = request.cache_parameter_group_name
+    if request.notification_topic_status:
+        modify_request['NotificationTopicStatus'] = request.notification_topic_status
+    if request.apply_immediately is not None:
+        modify_request['ApplyImmediately'] = request.apply_immediately
+    if request.engine_version:
+        modify_request['EngineVersion'] = request.engine_version
+    if request.auto_minor_version_upgrade is not None:
+        modify_request['AutoMinorVersionUpgrade'] = request.auto_minor_version_upgrade
+    if request.snapshot_retention_limit is not None:
+        modify_request['SnapshotRetentionLimit'] = request.snapshot_retention_limit
+    if request.snapshot_window:
+        modify_request['SnapshotWindow'] = request.snapshot_window
+    if request.cache_node_type:
+        modify_request['CacheNodeType'] = request.cache_node_type
+    if request.auth_token:
+        modify_request['AuthToken'] = request.auth_token
+    if request.auth_token_update_strategy:
+        modify_request['AuthTokenUpdateStrategy'] = request.auth_token_update_strategy
+    if request.log_delivery_configurations:
+        try:
+            processed_configs = process_log_delivery_configurations(
+                request.log_delivery_configurations
+            )
+            modify_request['LogDeliveryConfigurations'] = processed_configs
+        except ValueError as e:
+            return {'error': str(e)}
+    if request.scale_config:
+        try:
+            processed_scale_config = process_scale_config(request.scale_config)
+            modify_request['ScaleConfig'] = processed_scale_config
+        except ValueError as e:
+            return {'error': str(e)}
+
+    # Modify the cache cluster
+    response = elasticache_client.modify_cache_cluster(**modify_request)
+    return response

awslabs/elasticache_mcp_server/tools/cc/parsers.py

@@ -0,0 +1,78 @@
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Parser functions for ElastiCache cache cluster tools."""
+
+from typing import Any, Dict
+
+
+def parse_shorthand_scale_config(config: str) -> Dict[str, Any]:
+    """Parse a scale configuration from shorthand syntax.
+
+    Args:
+        config: Shorthand syntax string for scale configuration
+            Format: ReplicasPerNodeGroup=int,AutomaticFailoverEnabled=bool,ScaleOutEnabled=bool,
+                   ScaleInEnabled=bool,TargetCapacity=int,MinCapacity=int,MaxCapacity=int
+
+    Returns:
+        Dictionary containing the parsed scale configuration
+
+    Raises:
+        ValueError: If the syntax is invalid
+    """
+    if not config:
+        raise ValueError('Empty scale configuration')
+
+    result = {}
+    pairs = config.split(',')
+
+    # Define valid keys and their processors
+    key_processors = {
+        'ReplicasPerNodeGroup': int,
+        'AutomaticFailoverEnabled': lambda x: x.lower() == 'true',
+        'ScaleOutEnabled': lambda x: x.lower() == 'true',
+        'ScaleInEnabled': lambda x: x.lower() == 'true',
+        'TargetCapacity': int,
+        'MinCapacity': int,
+        'MaxCapacity': int,
+    }
+
+    for pair in pairs:
+        if '=' not in pair:
+            raise ValueError(f'Invalid format. Each parameter must be in key=value format: {pair}')
+
+        key, value = pair.split('=', 1)
+        if not key or not value:
+            raise ValueError(f'Empty key or value: {pair}')
+
+        if key not in key_processors:
+            raise ValueError(f'Invalid parameter: {key}')
+
+        try:
+            result[key] = key_processors[key](value)
+        except ValueError as e:
+            raise ValueError(f'Invalid value for {key}: {value}') from e
+
+    # Validate capacity values if present
+    if 'MinCapacity' in result and 'MaxCapacity' in result:
+        if result['MinCapacity'] > result['MaxCapacity']:
+            raise ValueError('MinCapacity cannot be greater than MaxCapacity')
+        if 'TargetCapacity' in result:
+            if (
+                result['TargetCapacity'] < result['MinCapacity']
+                or result['TargetCapacity'] > result['MaxCapacity']
+            ):
+                raise ValueError('TargetCapacity must be between MinCapacity and MaxCapacity')
+
+    return result

awslabs/elasticache_mcp_server/tools/cc/processors.py

@@ -0,0 +1,74 @@
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Processor functions for ElastiCache cache cluster tools."""
+
+from .parsers import parse_shorthand_scale_config
+from typing import Dict, Union
+
+
+def process_scale_config(scale_config: Union[str, Dict]) -> Dict:
+    """Process scale configuration in either shorthand or JSON format.
+
+    Args:
+        scale_config: Scale configuration in either format
+            Shorthand format: "ReplicasPerNodeGroup=int,AutomaticFailoverEnabled=bool,..."
+            JSON format: Dictionary with scale configuration parameters
+
+    Returns:
+        Dictionary containing the processed scale configuration
+
+    Raises:
+        ValueError: If the configuration is invalid
+    """
+    if isinstance(scale_config, str):
+        # Parse shorthand syntax
+        try:
+            return parse_shorthand_scale_config(scale_config)
+        except ValueError as e:
+            raise ValueError(f'Invalid scale config shorthand syntax: {str(e)}')
+    else:
+        # Handle JSON format
+        if not isinstance(scale_config, dict):
+            raise ValueError('Scale configuration must be a dictionary or a shorthand string')
+
+        # Validate required fields and types
+        field_types = {
+            'ReplicasPerNodeGroup': int,
+            'AutomaticFailoverEnabled': bool,
+            'ScaleOutEnabled': bool,
+            'ScaleInEnabled': bool,
+            'TargetCapacity': int,
+            'MinCapacity': int,
+            'MaxCapacity': int,
+        }
+
+        processed_config = {}
+        for field, field_type in field_types.items():
+            if field in scale_config:
+                if not isinstance(scale_config[field], field_type):
+                    raise ValueError(f'{field} must be of type {field_type.__name__}')
+                processed_config[field] = scale_config[field]
+
+        # Validate capacity values if present
+        if 'MinCapacity' in processed_config and 'MaxCapacity' in processed_config:
+            if processed_config['MinCapacity'] > processed_config['MaxCapacity']:
+                raise ValueError('MinCapacity cannot be greater than MaxCapacity')
+            if 'TargetCapacity' in processed_config and (
+                processed_config['TargetCapacity'] < processed_config['MinCapacity']
+                or processed_config['TargetCapacity'] > processed_config['MaxCapacity']
+            ):
+                raise ValueError('TargetCapacity must be between MinCapacity and MaxCapacity')
+
+        return processed_config

awslabs/elasticache_mcp_server/tools/ce/__init__.py

@@ -0,0 +1,19 @@
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Cost Explorer tools for ElastiCache MCP server."""
+
+from .get_cost_and_usage import get_cost_and_usage, GetCostAndUsageRequest
+
+__all__ = ['get_cost_and_usage', 'GetCostAndUsageRequest']

awslabs/elasticache_mcp_server/tools/ce/get_cost_and_usage.py

@@ -0,0 +1,76 @@
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Get cost and usage data for ElastiCache resources."""
+
+from ...common.connection import CostExplorerConnectionManager
+from ...common.decorators import handle_exceptions
+from ...common.server import mcp
+from pydantic import BaseModel, ConfigDict, Field
+from typing import Any, Dict
+
+
+class GetCostAndUsageRequest(BaseModel):
+    """Request model for getting cost and usage data."""
+
+    model_config = ConfigDict(validate_by_name=True, arbitrary_types_allowed=True)
+
+    time_period: str = Field(
+        ..., description='Time period for the cost and usage data. Format: YYYY-MM-DD/YYYY-MM-DD'
+    )
+    granularity: str = Field(
+        ..., description='The granularity of the cost and usage data (DAILY, MONTHLY, or HOURLY)'
+    )
+
+
+@mcp.tool(name='get-cost-and-usage')
+@handle_exceptions
+async def get_cost_and_usage(request: GetCostAndUsageRequest) -> Dict[str, Any]:
+    """Get cost and usage data for ElastiCache resources.
+
+    This tool retrieves cost and usage data for ElastiCache resources with customizable
+    time periods and granularity. It uses default configurations for:
+    - Metrics: BlendedCost, UnblendedCost, UsageQuantity
+    - Group By: SERVICE dimension and Environment tag
+    - Filter: Filtered to Amazon ElastiCache service
+
+    Args:
+        request: The GetCostAndUsageRequest object containing:
+            - time_period: Time period in YYYY-MM-DD/YYYY-MM-DD format
+            - granularity: Data granularity (DAILY, MONTHLY, or HOURLY)
+
+    Returns:
+        Dict containing the cost and usage data.
+    """
+    # Get Cost Explorer client
+    ce_client = CostExplorerConnectionManager.get_connection()
+
+    # Split time period into start and end dates
+    start_date, end_date = request.time_period.split('/')
+
+    # Prepare request parameters
+    params = {
+        'TimePeriod': {'Start': start_date, 'End': end_date},
+        'Granularity': request.granularity,
+        'Metrics': ['BlendedCost', 'UnblendedCost', 'UsageQuantity'],
+        'GroupBy': [
+            {'Type': 'DIMENSION', 'Key': 'SERVICE'},
+            {'Type': 'TAG', 'Key': 'Environment'},
+        ],
+        'Filter': {'Dimensions': {'Key': 'SERVICE', 'Values': ['Amazon ElastiCache']}},
+    }
+
+    # Get cost and usage data
+    response = ce_client.get_cost_and_usage(**params)
+    return response

awslabs/elasticache_mcp_server/tools/cw/__init__.py

@@ -0,0 +1,19 @@
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""CloudWatch tools."""
+
+from .get_metric_statistics import get_metric_statistics
+
+__all__ = ['get_metric_statistics']

awslabs/elasticache_mcp_server/tools/cw/get_metric_statistics.py

@@ -0,0 +1,85 @@
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Tool for getting CloudWatch metric statistics."""
+
+from ...common.connection import CloudWatchConnectionManager
+from ...common.decorators import handle_exceptions
+from ...common.server import mcp
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+
+@mcp.tool(name='get-metric-statistics')
+@handle_exceptions
+async def get_metric_statistics(
+    metric_name: str,
+    start_time: str,
+    end_time: str,
+    period: int,
+    dimensions: Optional[List[Dict[str, str]]] = None,
+    statistics: Optional[List[str]] = None,
+    extended_statistics: Optional[List[str]] = None,
+    unit: Optional[str] = None,
+) -> Dict[str, Any]:
+    """Get CloudWatch metric statistics.
+
+    Args:
+        metric_name: The name of the metric
+        start_time: The start time in ISO 8601 format
+        end_time: The end time in ISO 8601 format
+        period: The granularity, in seconds, of the returned data points
+        dimensions: The dimensions to filter by
+        statistics: The metric statistics to return
+        extended_statistics: The percentile statistics to return
+        unit: The unit for the metric
+
+    Returns:
+        Dict containing metric statistics
+    """
+    client = CloudWatchConnectionManager.get_connection()
+
+    # Convert ISO 8601 strings to datetime objects
+    start = datetime.fromisoformat(start_time.replace('Z', '+00:00'))
+    end = datetime.fromisoformat(end_time.replace('Z', '+00:00'))
+
+    # Build request parameters
+    params: Dict[str, Any] = {
+        'Namespace': 'AWS/ElastiCache',
+        'MetricName': metric_name,
+        'StartTime': start,
+        'EndTime': end,
+        'Period': period,
+    }
+
+    # Add optional parameters
+    if dimensions:
+        params['Dimensions'] = [{'Name': k, 'Value': v} for d in dimensions for k, v in d.items()]
+    if statistics:
+        params['Statistics'] = statistics
+    if extended_statistics:
+        params['ExtendedStatistics'] = extended_statistics
+    if unit:
+        params['Unit'] = unit
+
+    # Make API call
+    response = client.get_metric_statistics(**params)
+
+    # Extract relevant information
+    datapoints = response.get('Datapoints', [])
+    label = response.get('Label')
+
+    result = {'Label': label, 'Datapoints': datapoints}
+
+    return result