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]