def delete_subscription_filter(self, filter_name):
if (not self.subscription_filters
or self.subscription_filters[0]["filterName"] != filter_name):
raise ResourceNotFoundException(
"The specified subscription filter does not exist.")
self.subscription_filters = []
def delete_subscription_filter(self, log_group_name, filter_name):
log_group = self.groups.get(log_group_name)
if not log_group:
raise ResourceNotFoundException()
log_group.delete_subscription_filter(filter_name)
def put_log_events(self, log_group_name, log_stream_name, log_events,
sequence_token):
# TODO: add support for sequence_tokens
if log_group_name not in self.groups:
raise ResourceNotFoundException()
log_group = self.groups[log_group_name]
# Only events from the last 14 days or 2 hours in the future are accepted
rejected_info = {}
allowed_events = []
last_timestamp = None
oldest = int(unix_time_millis(datetime.utcnow() - timedelta(days=14)))
newest = int(unix_time_millis(datetime.utcnow() + timedelta(hours=2)))
for idx, event in enumerate(log_events):
if last_timestamp and last_timestamp > event["timestamp"]:
raise InvalidParameterException(
"Log events in a single PutLogEvents request must be in chronological order."
)
if event["timestamp"] < oldest:
rejected_info["tooOldLogEventEndIndex"] = idx
elif event["timestamp"] > newest:
rejected_info["tooNewLogEventStartIndex"] = idx
else:
allowed_events.append(event)
last_timestamp = event["timestamp"]
token = log_group.put_log_events(log_group_name, log_stream_name,
allowed_events, sequence_token)
return token, rejected_info
def put_log_events(self, log_group_name, log_stream_name, log_events):
if log_stream_name not in self.streams:
raise ResourceNotFoundException(
"The specified log stream does not exist.")
stream = self.streams[log_stream_name]
return stream.put_log_events(log_group_name, log_stream_name,
log_events)
def filter_log_events(
self,
log_group_name,
log_stream_names,
start_time,
end_time,
limit,
next_token,
filter_pattern,
interleaved,
):
if log_group_name not in self.groups:
raise ResourceNotFoundException()
if limit and limit > 1000:
raise InvalidParameterException(
constraint="Member must have value less than or equal to 10000",
parameter="limit",
value=limit,
)
log_group = self.groups[log_group_name]
return log_group.filter_log_events(
log_group_name,
log_stream_names,
start_time,
end_time,
limit,
next_token,
filter_pattern,
interleaved,
)
def delete_resource_policy(self, policy_name):
"""Remove resource policy with a policy name matching given name."""
if policy_name not in self.resource_policies:
raise ResourceNotFoundException(
msg=f"Policy with name [{policy_name}] does not exist")
del self.resource_policies[policy_name]
return ""
def describe_subscription_filters(self, log_group_name):
log_group = self.groups.get(log_group_name)
if not log_group:
raise ResourceNotFoundException()
return log_group.describe_subscription_filters()
def put_log_events(self, log_group_name, log_stream_name, log_events,
sequence_token):
# TODO: add support for sequence_tokens
if log_group_name not in self.groups:
raise ResourceNotFoundException()
log_group = self.groups[log_group_name]
return log_group.put_log_events(log_group_name, log_stream_name,
log_events, sequence_token)
def start_query(self, log_group_names, start_time, end_time, query_string):
for log_group_name in log_group_names:
if log_group_name not in self.groups:
raise ResourceNotFoundException()
query_id = uuid.uuid1()
self.queries[query_id] = LogQuery(query_id, start_time, end_time, query_string)
return query_id
def put_subscription_filter(*args, **kwargs):
log_group_name = args[0]
filter_name = args[1]
filter_pattern = args[2]
destination_arn = args[3]
role_arn = args[4]
log_group = logs_models.logs_backends[
aws_stack.get_region()].groups.get(log_group_name)
if not log_group:
raise ResourceNotFoundException(
'The specified log group does not exist.')
if ':lambda:' in destination_arn:
client = aws_stack.connect_to_service('lambda')
lambda_name = aws_stack.lambda_function_name(destination_arn)
try:
client.get_function(FunctionName=lambda_name)
except Exception:
raise InvalidParameterException(
'destinationArn for vendor lambda cannot be used with roleArn'
)
elif ':kinesis:' in destination_arn:
client = aws_stack.connect_to_service('kinesis')
stream_name = aws_stack.kinesis_stream_name(destination_arn)
try:
client.describe_stream(StreamName=stream_name)
except Exception:
raise InvalidParameterException(
'Could not deliver test message to specified Kinesis stream. '
'Check if the given kinesis stream is in ACTIVE state. '
)
elif ':firehose:' in destination_arn:
client = aws_stack.connect_to_service('firehose')
firehose_name = aws_stack.firehose_name(destination_arn)
try:
client.describe_delivery_stream(
DeliveryStreamName=firehose_name)
except Exception:
raise InvalidParameterException(
'Could not deliver test message to specified Firehose stream. '
'Check if the given Firehose stream is in ACTIVE state.'
)
else:
service = aws_stack.extract_service_from_arn(destination_arn)
raise InvalidParameterException(
'PutSubscriptionFilter operation cannot work with destinationArn for vendor %s'
% service)
log_group.put_subscription_filter(filter_name, filter_pattern,
destination_arn, role_arn)
def moto_put_subscription_filter(fn, self, *args, **kwargs):
log_group_name = args[0]
filter_name = args[1]
filter_pattern = args[2]
destination_arn = args[3]
role_arn = args[4]
log_group = self.groups.get(log_group_name)
if not log_group:
raise ResourceNotFoundException("The specified log group does not exist.")
if ":lambda:" in destination_arn:
client = aws_stack.connect_to_service("lambda")
lambda_name = aws_stack.lambda_function_name(destination_arn)
try:
client.get_function(FunctionName=lambda_name)
except Exception:
raise InvalidParameterException(
"destinationArn for vendor lambda cannot be used with roleArn"
)
elif ":kinesis:" in destination_arn:
client = aws_stack.connect_to_service("kinesis")
stream_name = aws_stack.kinesis_stream_name(destination_arn)
try:
client.describe_stream(StreamName=stream_name)
except Exception:
raise InvalidParameterException(
"Could not deliver test message to specified Kinesis stream. "
"Check if the given kinesis stream is in ACTIVE state. "
)
elif ":firehose:" in destination_arn:
client = aws_stack.connect_to_service("firehose")
firehose_name = aws_stack.firehose_name(destination_arn)
try:
client.describe_delivery_stream(DeliveryStreamName=firehose_name)
except Exception:
raise InvalidParameterException(
"Could not deliver test message to specified Firehose stream. "
"Check if the given Firehose stream is in ACTIVE state."
)
else:
service = aws_stack.extract_service_from_arn(destination_arn)
raise InvalidParameterException(
f"PutSubscriptionFilter operation cannot work with destinationArn for vendor {service}"
)
if filter_pattern:
for stream in log_group.streams.values():
stream.filter_pattern = filter_pattern
log_group.put_subscription_filter(filter_name, filter_pattern, destination_arn, role_arn)
def create_export_task(
self,
*,
task_name,
log_group_name,
log_stream_name_prefix,
fromTime,
to,
destination,
destination_prefix,
):
s3_backend.get_bucket(destination)
if log_group_name not in self.groups:
raise ResourceNotFoundException()
task_id = uuid.uuid4()
return task_id
def get_log_events(
self,
log_stream_name,
start_time,
end_time,
limit,
next_token,
start_from_head,
):
if log_stream_name not in self.streams:
raise ResourceNotFoundException()
stream = self.streams[log_stream_name]
return stream.get_log_events(
start_time,
end_time,
limit,
next_token,
start_from_head,
)
def describe_log_streams(
self,
descending,
limit,
log_group_name,
log_stream_name_prefix,
next_token,
order_by,
):
if log_group_name not in self.groups:
raise ResourceNotFoundException()
log_group = self.groups[log_group_name]
return log_group.describe_log_streams(
descending,
limit,
log_group_name,
log_stream_name_prefix,
next_token,
order_by,
)
def put_subscription_filter(self, log_group_name, filter_name,
filter_pattern, destination_arn, role_arn):
log_group = self.groups.get(log_group_name)
if not log_group:
raise ResourceNotFoundException()
service = destination_arn.split(":")[2]
if service == "lambda":
from moto.awslambda import ( # pylint: disable=import-outside-toplevel
lambda_backends, )
lambda_func = lambda_backends[self.region_name].get_function(
destination_arn)
# no specific permission check implemented
if not lambda_func:
raise InvalidParameterException(
"Could not execute the lambda function. Make sure you "
"have given CloudWatch Logs permission to execute your "
"function.")
elif service == "firehose":
from moto.firehose import ( # pylint: disable=import-outside-toplevel
firehose_backends, )
firehose = firehose_backends[
self.region_name].lookup_name_from_arn(destination_arn)
if not firehose:
raise InvalidParameterException(
"Could not deliver test message to specified Firehose "
"stream. Check if the given Firehose stream is in ACTIVE "
"state.")
else:
# TODO: support Kinesis stream destinations
raise InvalidParameterException(
f"Service '{service}' has not implemented for "
f"put_subscription_filter()")
log_group.put_subscription_filter(filter_name, filter_pattern,
destination_arn, role_arn)
def get_log_events(
self,
log_group_name,
log_stream_name,
start_time,
end_time,
limit,
next_token,
start_from_head,
):
if log_group_name not in self.groups:
raise ResourceNotFoundException()
log_group = self.groups[log_group_name]
return log_group.get_log_events(
log_group_name,
log_stream_name,
start_time,
end_time,
limit,
next_token,
start_from_head,
)
def put_subscription_filter(self, log_group_name, filter_name,
filter_pattern, destination_arn, role_arn):
# TODO: support other destinations like Kinesis stream
from moto.awslambda import lambda_backends # due to circular dependency
log_group = self.groups.get(log_group_name)
if not log_group:
raise ResourceNotFoundException()
lambda_func = lambda_backends[self.region_name].get_function(
destination_arn)
# no specific permission check implemented
if not lambda_func:
raise InvalidParameterException(
"Could not execute the lambda function. "
"Make sure you have given CloudWatch Logs permission to execute your function."
)
log_group.put_subscription_filter(filter_name, filter_pattern,
destination_arn, role_arn)
def describe_log_streams(
self,
descending,
limit,
log_group_name,
log_stream_name_prefix,
next_token,
order_by,
):
if log_group_name not in self.groups:
raise ResourceNotFoundException()
if limit > 50:
raise InvalidParameterException(
constraint="Member must have value less than or equal to 50",
parameter="limit",
value=limit,
)
if order_by not in ["LogStreamName", "LastEventTime"]:
raise InvalidParameterException(
constraint=
"Member must satisfy enum value set: [LogStreamName, LastEventTime]",
parameter="orderBy",
value=order_by,
)
if order_by == "LastEventTime" and log_stream_name_prefix:
raise InvalidParameterException(
msg="Cannot order by LastEventTime with a logStreamNamePrefix."
)
log_group = self.groups[log_group_name]
return log_group.describe_log_streams(
descending,
limit,
log_group_name,
log_stream_name_prefix,
next_token,
order_by,
)
def filter_log_events(
self,
log_group_name,
log_stream_names,
start_time,
end_time,
limit,
next_token,
filter_pattern,
interleaved,
):
if log_group_name not in self.groups:
raise ResourceNotFoundException()
log_group = self.groups[log_group_name]
return log_group.filter_log_events(
log_group_name,
log_stream_names,
start_time,
end_time,
limit,
next_token,
filter_pattern,
interleaved,
)
def delete_log_group(self, log_group_name):
if log_group_name not in self.groups:
raise ResourceNotFoundException()
del self.groups[log_group_name]
def untag_log_group(self, log_group_name, tags):
if log_group_name not in self.groups:
raise ResourceNotFoundException()
log_group = self.groups[log_group_name]
log_group.untag(tags)
def list_tags_log_group(self, log_group_name):
if log_group_name not in self.groups:
raise ResourceNotFoundException()
log_group = self.groups[log_group_name]
return log_group.list_tags()
def create_export_task(self, log_group_name, destination):
s3_backend.get_bucket(destination)
if log_group_name not in self.groups:
raise ResourceNotFoundException()
task_id = uuid.uuid4()
return task_id
def delete_retention_policy(self, log_group_name):
if log_group_name not in self.groups:
raise ResourceNotFoundException()
log_group = self.groups[log_group_name]
return log_group.set_retention_policy(None)
def put_retention_policy(self, log_group_name, retention_in_days):
if log_group_name not in self.groups:
raise ResourceNotFoundException()
log_group = self.groups[log_group_name]
return log_group.set_retention_policy(retention_in_days)
def delete_log_stream(self, log_group_name, log_stream_name):
if log_group_name not in self.groups:
raise ResourceNotFoundException()
log_group = self.groups[log_group_name]
return log_group.delete_log_stream(log_stream_name)
def delete_log_stream(self, log_stream_name):
if log_stream_name not in self.streams:
raise ResourceNotFoundException()
del self.streams[log_stream_name]