def init(dsn: str = None, context: dict = None):
if not dsn:
dsn = config("SENTRY_DSN")
sentry_sdk.init(dsn=dsn, integrations=[AwsLambdaIntegration()])
if context:
with sentry_sdk.configure_scope() as scope:
_set_tags(scope, context)
def initialize_sentry() -> None:
"""Initialize Sentry monitoring.
To enable Sentry, please define
settings "project.sentry_dsn" or
environment SENTRY_ENDPOINT.
"""
endpoint = settings["project.sentry_dsn"]
if not endpoint:
logger.warning("Sentry not initialized.")
return
toml_path = Path().cwd().joinpath("pyproject.toml")
with open(str(toml_path), "r") as file:
data = Cut(toml.load(file))
current_version = data["tool.poetry.version"]
try:
sentry_sdk.init(
dsn=endpoint,
integrations=[AwsLambdaIntegration()],
environment=settings.stela_options.current_environment,
release=current_version,
)
logger.info("Sentry initialized.")
except BadDsn as error:
logger.error(f"Error when initializing Sentry: {error}")
def init_sentry(cli=False):
if cli:
return
sentry_sdk.init(
dsn="https://[email protected]/2153273",
integrations=[AwsLambdaIntegration()],
)
def sentry_init(): # pragma: no cover
try:
import sentry_sdk
from sentry_sdk.integrations.aws_lambda import AwsLambdaIntegration
except ImportError:
pass
else:
# The Sentry DSN is set in the SENTRY_DSN environmental variable
sentry_sdk.init(integrations=[AwsLambdaIntegration()])
def init_sentry():
sentry_sdk.init(
dsn=settings.sentry_dsn,
integrations=[AwsLambdaIntegration()],
traces_sample_rate=1.0, # adjust the sample rate in production as needed
environment=settings.environment,
release=settings.vcs_rev,
send_default_pii=True,
)
def init():
Config.init()
registry.initialize()
sentry_sdk.init(
dsn=Config.Constants.SENTRY_DSN,
environment=Config.Constants.SENTRY_ENVIRONMENT,
integrations=[AwsLambdaIntegration()],
traces_sample_rate=1.0, # adjust the sample rate in production as needed
)
def initialise_sentry():
global sentry_initialised
if os.environ.get("SENTRY_DSN", "") and not sentry_initialised:
sentry_sdk.init(
os.environ.get("SENTRY_DSN"),
integrations=[
AwsLambdaIntegration(),
FlaskIntegration(),
AioHttpIntegration(),
],
traces_sample_rate=0.01,
)
sentry_initialised = True
def configure_sentry():
if not has_sentry:
return
secret_id = os.getenv('SENTRY_DSN_SECRET_ID')
if not secret_id:
return
# Pull from secrets manager
secrets_manager = boto3.client('secretsmanager')
dsn = secrets_manager.get_secret_value(secret_id)['SecretString']
if dsn:
sentry_sdk.init(
dsn=dsn,
integrations=[AwsLambdaIntegration()],
environment=os.getenv('Stage')
)
def init_monitoring():
dsn = environ.get(MONITORING_DSN)
env = environ.get(OPERATING_ENV)
if not dsn:
warning(f'DSN not found in envronment under key {MONITORING_DSN}')
return
info(f'Configuring monitoring via DSN: {dsn}')
init(
dsn=dsn,
integrations=[AwsLambdaIntegration()],
release=f'v{version}',
send_default_pii=False,
traces_sample_rate=0.50,
environment=env,
_experiments={'auto_enabling_integrations': True},
)
def create_app(config_object=None):
"""
FLASK_ENV=development FLASK_APP=apis.subscriptions.app flask run
"""
if config_object is None:
config_object = Config
app = Flask(__name__)
app.config.from_object(config_object)
SENTRY_DSN = app.config.get("SENTRY_DSN")
if SENTRY_DSN:
import sentry_sdk
from sentry_sdk.integrations.flask import FlaskIntegration
from sentry_sdk.integrations.aws_lambda import AwsLambdaIntegration
sentry_sdk.init(SENTRY_DSN, integrations=[FlaskIntegration(), AwsLambdaIntegration()])
app.register_blueprint(index.blueprint)
app.register_blueprint(subscriptions.blueprint)
handlers.register(app)
return app
def run(event, context):
""" run the process to retrieve and process web kiosk metadata """
if config != {}:
sentry_error_dsn = config['sentry']['dsn']
sentry_environment = config['sentry']['environment']
init(sentry_error_dsn,
environment=sentry_environment,
integrations=[AwsLambdaIntegration()])
web_kiosk_class = process_web_kiosk_metadata(config)
xml_as_string = web_kiosk_class.get_snite_composite_mets_metadata()
if xml_as_string > '':
clean_up_as_we_go = True
web_kiosk_class.process_snite_composite_mets_metadata(
clean_up_as_we_go)
else:
print('Nothing to process')
else:
print('No configuration defined. Unable to continue.')
return event
def create_app(config_object=None):
"""
FLASK_ENV=development FLASK_APP=apis.document.app flask run --port=5003
"""
if config_object is None:
config_object = Config
app = Flask(__name__)
app.request_class = BigMemoryRequest
app.config.from_object(config_object)
SENTRY_DSN = app.config.get("SENTRY_DSN")
if SENTRY_DSN:
import sentry_sdk
from sentry_sdk.integrations.flask import FlaskIntegration
from sentry_sdk.integrations.aws_lambda import AwsLambdaIntegration
sentry_sdk.init(SENTRY_DSN, integrations=[FlaskIntegration(), AwsLambdaIntegration()])
app.register_blueprint(index.blueprint)
app.register_blueprint(documents.blueprint)
handlers.register(app)
register_specs(app, spec, views=('document_post', 'document_fetch',))
return app
def create_app(config_object=None):
"""
FLASK_ENV=development FLASK_APP=message_api.app flask run --port=5001
"""
if config_object is None:
config_object = Config
app = Flask(__name__)
app.config.from_object(config_object)
SENTRY_DSN = app.config.get("SENTRY_DSN")
if SENTRY_DSN:
import sentry_sdk
from sentry_sdk.integrations.flask import FlaskIntegration
from sentry_sdk.integrations.aws_lambda import AwsLambdaIntegration
sentry_sdk.init(
SENTRY_DSN,
integrations=[FlaskIntegration(),
AwsLambdaIntegration()])
app.register_blueprint(index.blueprint)
app.register_blueprint(message.blueprint)
handlers.register(app)
register_specs(app,
spec,
views=('message_retrieve', 'message_patch', 'message_post'))
return app
def init(run_id=None):
'''
1. Init sentry exception tracking
2. Improve default log formatting
3. Silence noise logger(s)
:param run_id: Parameter can be provided as reference to find all logs
that belong to a single run of a serverless function
'''
sentry_config = _config.get_config().get('sentry')
if not sentry_config:
return
sentry_key = sentry_config['key']
sentry_project = sentry_config['project']
if not run_id:
run_id = _generate_id()
log_format = '%(levelname)s:\n%(name)s:{}: %(message)s'.format(run_id)
if _config.get_env() in ['staging', 'production']:
log_format = log_format.replace('\n', '\r')
logging.basicConfig(level=logging.INFO, format=log_format)
# silence botocore logs
logging.getLogger('botocore').setLevel(logging.WARNING)
if _config.get_env() in ['staging', 'production']:
log_format = log_format.replace('\n', '\r')
logging.basicConfig(level=logging.INFO, format=log_format)
sentry_sdk.init(
dsn="https://{key}@sentry.io/{project}".format(key=sentry_key, project=sentry_project),
integrations=[AwsLambdaIntegration()]
)
import logging
from logging.config import dictConfig
import sentry_sdk
from sentry_sdk.integrations.logging import LoggingIntegration
from sentry_sdk.integrations.aws_lambda import AwsLambdaIntegration
from intergov.conf import env_bool, env
SENTRY_DSN = env('SENTRY_DSN', default=None)
if SENTRY_DSN: # pragma: no cover
sentry_sdk.init(
dsn=SENTRY_DSN,
integrations=[LoggingIntegration(),
AwsLambdaIntegration()])
with sentry_sdk.configure_scope() as scope:
scope.set_tag("service", "intergov")
scope.set_tag("country", env("ICL_APP_COUNTRY", default=""))
LOGGING = {
'version': 1,
'disable_existing_loggers': False,
'formatters': {
'verbose': {
'format': '%(asctime)-15s %(levelname)s [%(name)s] %(message)s'
}
},
'handlers': {
'console': {
# /**
# *******************************************************************************
# * File name : network_error_wrong_address.py
# * Description : This file contains code that instruments calling APIs of a
# * Flask App and producing Network Connection error using wrong
# * IP Address.
# *******************************************************************************
# **/
# Import Sentry library
import sentry_sdk
from sentry_sdk.integrations.aws_lambda import AwsLambdaIntegration
import requests
# Configure Sentry SDK
sentry_sdk.init(dsn="<your DSN>", integrations=[AwsLambdaIntegration()])
# Constants
CORRECT_PORT = "80"
WRONG_IP = "192.0.2.1" # Dummy IP which does not exist
WRONG_URL = "http://" + WRONG_IP + ":" + CORRECT_PORT
API = "/test" # Dummy API
def lambda_handler(event, context):
"""Lambda function which does REST API calls ond returns url.
Args:
event (dict): Parameter to pass in event data to the handler.
context (bootstrap.LambdaContext): Parameter to provide runtime information to the handler.
def _init_sentry():
if 'SENTRY_DSN' in os.environ:
sentry_sdk.init(dsn=os.environ['SENTRY_DSN'], integrations=[AwsLambdaIntegration()])
# AWS Lambda Handler
#
# Use Dockerfile.lambda to package/upload (see the instructions in the Dockerfile)
#
import json, os
import boto3, botocore
# TODO setup sentry and add to AWS Lambda Env
if "SENTRY_DSN" in os.environ:
import sentry_sdk
from sentry_sdk.integrations.aws_lambda import AwsLambdaIntegration
sentry_sdk.init(dsn=os.environ["SENTRY_DSN"],
integrations=[AwsLambdaIntegration(timeout_warning=True)])
def lambda_handler(event, context, local_output=False):
# ALWAYs store token in env, not in code!
salesforce_token = os.environ.get("SALESFORCE_TOKEN", None)
if salesforce_token:
pass #TODO query salesforce
else:
data = json.loads(open("data/211sample.json").read())
# TODO process Data
result = [o for o in data if o['service']['Service_Status__c'] == "Active"]
# TODO push to S3 location
output_filename = "sandiego-foodmap-data.json"
if local_output:
import boto3
import logging
import datetime
import os
from slugify import slugify
import sentry_sdk
from sentry_sdk.integrations.aws_lambda import AwsLambdaIntegration
sentry_sdk.init(dsn=os.environ.get('SENTRY_DSN'), integrations=[AwsLambdaIntegration()])
from ..utils.common_db_utils import chunks, BATCH_WRITE_CHUNK_SIZE
from common.utils.idea_utils import sanitize_idea_content, prepare_idea_tags_for_put_request, \
prepare_idea_tags_for_delete_request, strip_html
# logger = logging.getLogger()
# logger.setLevel(logging.INFO)
def endpoint(event, lambda_context):
ctx = event.get('ctx')
arguments = ctx.get('arguments')
title = arguments.get('title')
slug = slugify(title)
content = sanitize_idea_content(arguments.get('content', None))
stripped_content = None
if content:
stripped_content = strip_html(content)
idea_id = arguments.get('ideaId', None)
idea_owner_id = arguments.get('ideaOwnerId', None)
def init_logger(self):
"""
Initialize the logger. Call exactly once.
"""
log_formatter = BalsaFormatter(self.log_formatter_string)
assert self.name is not None
assert self.author is not None
self.handlers = {}
if self.is_root:
self.log = logging.getLogger()
else:
self.log = logging.getLogger(self.name)
if not self.propagate:
self.log.propagate = False
# set the root log level
if self.verbose:
self.log.setLevel(logging.DEBUG)
else:
self.log.setLevel(logging.INFO)
if self.log.hasHandlers():
self.log.info("Logger already initialized.")
# use turn off file logging, e.g. for cloud environments where it's not recommended and/or possible to write to the local file system
if self.use_file_logging:
# create file handler
if self.log_directory is None:
self.log_directory = Path(
appdirs.user_log_dir(self.name, self.author))
if self.log_directory is not None:
if isinstance(self.log_directory, str):
self.log_directory = Path(self.log_directory)
self.log_directory.mkdir(parents=True, exist_ok=True)
if self.delete_existing_log_files:
# need to glob since there are potentially many files due to the "rotating" file handler
for file_path in Path.glob(self.log_directory,
f"*{self.log_extension}"):
try:
file_path.unlink()
except OSError:
pass
if self.instance_name is None:
file_name = f"{self.name}{self.log_extension}"
else:
file_name = f"{self.name}_{self.instance_name}{self.log_extension}"
self.log_path = Path(self.log_directory, file_name)
file_handler = logging.handlers.RotatingFileHandler(
self.log_path,
maxBytes=self.max_bytes,
backupCount=self.backup_count)
file_handler.setFormatter(log_formatter)
if self.verbose:
file_handler.setLevel(logging.DEBUG)
else:
file_handler.setLevel(logging.INFO)
self.log.addHandler(file_handler)
self.handlers[HandlerType.File] = file_handler
self.log.info(
f'log file path : "{self.log_path}" ("{self.log_path.absolute()}")'
)
if self.gui:
# GUI will only pop up a dialog box - it's important that GUI apps not try to output to stdout or stderr
# since that would likely cause a permissions error.
dialog_box_handler = DialogBoxHandler(self.rate_limits)
if self.verbose:
dialog_box_handler.setLevel(logging.WARNING)
else:
dialog_box_handler.setLevel(logging.ERROR)
self.log.addHandler(dialog_box_handler)
self.handlers[HandlerType.DialogBox] = dialog_box_handler
self.set_std() # redirect stdout and stderr to log
else:
console_handler = logging.StreamHandler()
# prefix for things like "\n" or "\r"
console_handler.setFormatter(
BalsaFormatter(
f"{self.log_console_prefix}{self.log_formatter_string}"))
if self.verbose:
console_handler.setLevel(logging.INFO)
else:
console_handler.setLevel(logging.WARNING)
self.log.addHandler(console_handler)
self.handlers[HandlerType.Console] = console_handler
string_list_handler = BalsaStringListHandler(
self.max_string_list_entries)
string_list_handler.setFormatter(log_formatter)
string_list_handler.setLevel(logging.INFO)
self.log.addHandler(string_list_handler)
self.handlers[HandlerType.StringList] = string_list_handler
# setting up Sentry error handling
# For the Client to work you need a SENTRY_DSN environmental variable set, or one must be provided.
if self.use_sentry:
if self.sentry_max_string_len is not None:
sentry_sdk.utils.MAX_STRING_LENGTH = self.sentry_max_string_len
sample_rate = 0.0 if self.inhibit_cloud_services else 1.0
integrations = []
if self.use_sentry_django:
from sentry_sdk.integrations.django import DjangoIntegration
integrations.append(DjangoIntegration())
if self.use_sentry_flask:
from sentry_sdk.integrations.flask import FlaskIntegration
integrations.append(FlaskIntegration())
if self.use_sentry_lambda:
from sentry_sdk.integrations.aws_lambda import AwsLambdaIntegration
integrations.append(AwsLambdaIntegration())
if self.use_sentry_sqlalchemy:
from sentry_sdk.integrations.sqlalchemy import SqlalchemyIntegration
integrations.append(SqlalchemyIntegration())
if self.use_sentry_celery:
from sentry_sdk.integrations.celery import CeleryIntegration
integrations.append(CeleryIntegration())
if self.sentry_dsn is None:
if (sentry_dsn := self.get_sentry_dsn_via_env_var()) is None:
raise ValueError(
"Missing Sentry DSN - either set as an environmental variable or a parameter to the Balsa constructor"
)
else:
sentry_sdk.init(
dsn=sentry_dsn,
sample_rate=sample_rate,
integrations=integrations,
)
else:
sentry_sdk.init(
dsn=self.sentry_dsn,
sample_rate=sample_rate,
integrations=integrations,
)
storage,
)
from common.serverless import utils
from common.serverless.error_handling import pubsub_function
from tess import Tesseract
# only initialize sentry on serverless
# pylint: disable=import-error
import sentry_sdk
from sentry_sdk.integrations.aws_lambda import AwsLambdaIntegration
from sentry_sdk.integrations.redis import RedisIntegration
# pylint: enable=import-error
sentry_sdk.init(
dsn=env("SENTRY_DSN"), integrations=[AwsLambdaIntegration(), RedisIntegration()]
)
REDIS = utils.get_redis()
OCR_TOPIC = publisher.topic_path(
"documentcloud", env.str("OCR_TOPIC", default="ocr-extraction-dev")
)
TEXT_POSITION_EXTRACT_TOPIC = publisher.topic_path(
"documentcloud",
env.str("TEXT_POSITION_EXTRACT_TOPIC", default="text-position-extraction"),
)
TEXT_POSITION_BATCH = env.int(
"TEXT_POSITION_BATCH", 3
) # Number of pages to pull text positions from with each function
import json
import boto3
import datetime
import sentry_sdk
from sentry_sdk.integrations.aws_lambda import AwsLambdaIntegration
# Automatically report all uncaught exceptions
sentry_sdk.init(dsn="url_sentry", integrations=[AwsLambdaIntegration()])
# from the type create a json, that is the config file, the json file upload on s3 will trigger the activation of the creation of the video through the video lambda function
def create_json(type, time): #type è uno dei valori (settimana,mese,year)
json_dict = {}
json_dict["info_video"] = {}
if type == 'year':
json_dict["year"] = str(time.year)
json_dict["fps"] = "10"
json_dict["grayscale"] = "0"
json_dict["frame_width"] = "1280"
json_dict["frame_height"] = "720"
json_dict["info_video"]["name"] = "year"
json_dict["info_video"]["format"] = "H264"
json_dict["info_video"]["extension"] = "mp4"
elif type == 'month':
end = time
delta = datetime.timedelta(days=end.day - 1)
begin = end - delta
json_dict["begin_date"] = begin.strftime('%Y-%m-%d')
json_dict["end_date"] = end.strftime('%Y-%m-%d')
json_dict["fps"] = "3"
json_dict["grayscale"] = "0"
def setup_sentry():
sentry_sdk.init(
dsn="https://[email protected]/1443649",
integrations=[AwsLambdaIntegration()]
)
class InstanceRefreshInProgress(LambdaError):
pass
AUTO_SCALING_GROUP_NAME = environ['AUTO_SCALING_GROUP_NAME']
DESCRIBE_INSTANCE_REFRESHES_MAX_RECORDS = int(
environ['DESCRIBE_INSTANCE_REFRESHES_MAX_RECORDS'])
FINISHED_INSTANCE_REFRESH_STATES = ('Cancelled', 'Failed', 'Successful')
LOGGING_LEVEL = environ.get('LOGGING_LEVEL', logging.INFO)
REFRESH_INSTANCE_WARMUP = int(environ['REFRESH_INSTANCE_WARMUP'])
REFRESH_MIN_HEALTHY_PERCENTAGE = int(environ['REFRESH_MIN_HEALTHY_PERCENTAGE'])
SSM_PARAMETER_NAME = environ['SSM_PARAMETER_NAME']
SENTRY_DSN = environ.get('SENTRY_DSN')
if SENTRY_DSN:
sentry_sdk.init(SENTRY_DSN, integrations=[AwsLambdaIntegration()])
logging.config.dictConfig({
'version': 1,
'formatters': {
'default': {
'format': '[%(asctime)s] <%(levelname)s>: %(message)s',
},
},
'handlers': {
'console': {
'class': 'logging.StreamHandler',
'formatter': 'default',
},
},
'root': {
import json
import logging
import config
from viberbot import Api
from viberbot.api.bot_configuration import BotConfiguration
import sentry_sdk
from sentry_sdk.integrations.aws_lambda import AwsLambdaIntegration
from bot import configure_viber, viber_response
sentry_sdk.init(
dsn=config.sentry_dsn,
environment=config.stage,
integrations=[AwsLambdaIntegration()],
)
# Logging is cool!
logger = logging.getLogger()
if logger.handlers:
for handler in logger.handlers:
logger.removeHandler(handler)
logging.basicConfig(level=logging.INFO)
OK_RESPONSE = {
"statusCode": 200,
"headers": {
"Content-Type": "application/json"
},
import boto3, jinja2, json, urllib, datetime, random
from twython import Twython
import credentials
import sentry_sdk, sentryDSN
from sentry_sdk.integrations.aws_lambda import AwsLambdaIntegration
#capture all unhandled exceptions
sentry_sdk.init(sentryDSN.DSN, integrations=[AwsLambdaIntegration()])
def getTweetID(device_UUID, chart_period, chart_type):
dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table('tweetIDs')
response = table.query(ConsistentRead=True,
ProjectionExpression=chart_type,
KeyConditionExpression=
'device_UUID = :devUUID AND chart_period = :period',
ExpressionAttributeValues={
':devUUID': device_UUID,
':period': chart_period,
})
try:
return response['Items'][0][chart_type]
except:
return -1
def uploadTweetID(device_UUID, chart_period, chart_type, tweetID):
dynamodb = boto3.resource('dynamodb')
import os
import json
import logging
import sentry_sdk
from sentry_sdk.integrations.aws_lambda import AwsLambdaIntegration
from book_feed.process_books import process_books, merge_similar_books
if not os.getenv("IS_LOCAL"):
sentry_sdk.init(integrations=[AwsLambdaIntegration()], )
logger = logging.getLogger()
logging.getLogger("botocore").setLevel(logging.WARNING)
logging.getLogger("boto3").setLevel(logging.WARNING)
logging.getLogger("urllib3").setLevel(logging.WARNING)
if os.getenv("IS_LOCAL"):
logging.basicConfig(level=logging.DEBUG)
logger.setLevel(logging.DEBUG)
else:
logging.basicConfig(level=logging.INFO)
logger.setLevel(logging.INFO)
def handle_book_offers_trigger(event, context):
namespace = event.get("namespace")
offer_filter = {}
if namespace:
offer_filter["dealer"] = namespace
return json.dumps(process_books(offer_filter), default=str)
def setup_sentry(SENTRY_DSN):
sentry_sdk.init(dsn=SENTRY_DSN, integrations=[AwsLambdaIntegration()])
"""
Just a wrapper around the actual script (cleanup) for serverless,
but adds sentry support
"""
import os
import sentry_sdk
from sentry_sdk.integrations.aws_lambda import AwsLambdaIntegration
import cleanup
sentry_sdk.init(dsn=os.getenv("SENTRY_DSN"), integrations=[AwsLambdaIntegration()])
def run(event, context):
cleanup.run()
)
from noiseblend.exception_handlers import (
CatchAllExceptionHandler,
NoiseblendAuthExceptionHandler,
NoiseblendExceptionHandler,
NoiseblendUnknownSlotExceptionHandler,
)
from noiseblend.helpers import cap, listify
from sentry_sdk.integrations.aws_lambda import AwsLambdaIntegration
logger = logging.getLogger()
logger.setLevel(logging.INFO)
patch_all()
sentry_dsn_file = Path(__file__).parent / "secrets" / "sentry_dsn"
sentry_sdk.init(sentry_dsn_file.read_text(), integrations=[AwsLambdaIntegration()])
sb = NoiseblendSkillBuilder(table_name="noiseblend", auto_create_table=False)
class NotImplementedHandler(AbstractRequestHandler):
def can_handle(self, handler_input):
return True
def handle(self, handler_input):
handler_input.response_builder.speak(NOT_IMPLEMENTED_YET)
return handler_input.response_builder.response
class DislikeIntentHandler(NoiseblendRequestHandler):
# pylint: disable=arguments-differ