def includeme(config: Optional[pyramid.config.Configurator] = None) -> None:
"""
Initialize the request tracking.
Use a X-Request-ID (or other) header to track all the logs related to a request
including on the sub services.
"""
global ID_HEADERS, DEFAULT_TIMEOUT
ID_HEADERS = [
"X-Request-ID", "X-Correlation-ID", "Request-ID", "X-Varnish",
"X-Amzn-Trace-Id"
]
if config is not None:
extra_header = config_utils.env_or_config(config,
"C2C_REQUEST_ID_HEADER",
"c2c.request_id_header")
if extra_header:
ID_HEADERS.insert(0, extra_header)
config.add_request_method(_gen_request_id,
"c2c_request_id",
reify=True)
DEFAULT_TIMEOUT = config_utils.env_or_config(
config,
"C2C_REQUESTS_DEFAULT_TIMEOUT",
"c2c.requests_default_timeout",
type_=float)
_patch_requests()
if config_utils.env_or_config(config, "C2C_SQL_REQUEST_ID",
"c2c.sql_request_id", False):
from . import _sql
_sql.init()
def includeme(config: Optional[pyramid.config.Configurator] = None) -> None:
"""
Initialize the broadcaster with Redis, if configured.
Otherwise, fall back to a fake local implementation.
"""
global _broadcaster
broadcast_prefix = config_utils.env_or_config(config, BROADCAST_ENV_KEY,
BROADCAST_CONFIG_KEY,
"broadcast_api_")
master, slave, _ = redis_utils.get(
config.get_settings() if config else None)
if _broadcaster is None:
if master is not None and slave is not None:
_broadcaster = redis.RedisBroadcaster(broadcast_prefix, master,
slave)
else:
_broadcaster = local.LocalBroadcaster()
LOG.info("Broadcast service setup using local implementation")
elif isinstance(_broadcaster, local.LocalBroadcaster
) and master is not None and slave is not None:
LOG.info("Switching from a local broadcaster to a redis broadcaster")
prev_broadcaster = _broadcaster
_broadcaster = redis.RedisBroadcaster(broadcast_prefix, master, slave)
_broadcaster.copy_local_subscriptions(prev_broadcaster)
def __init__(self, config: pyramid.config.Configurator) -> None:
config.add_route(
"c2c_health_check", config_utils.get_base_path(config) + r"/health_check", request_method="GET"
)
config.add_view(self._view, route_name="c2c_health_check", renderer="fast_json", http_cache=0)
self._checks: List[Tuple[str, Callable[[pyramid.request.Request], Any], int]] = []
self.name = config_utils.env_or_config(
config,
redis_utils.REDIS_SENTINELS_KEY,
redis_utils.REDIS_SENTINELS_KEY_PROP,
config_utils.env_or_config(config, redis_utils.REDIS_URL_KEY, redis_utils.REDIS_URL_KEY_PROP),
)
if self.name:
self.add_redis_check(level=2)
if version.get_version() is not None:
self.add_version_check(level=2)
def includeme(config: Optional[pyramid.config.Configurator] = None) -> None:
"""Initialize the Redis tracking."""
global ORIG
if config_utils.env_or_config(config, "C2C_TRACK_REDIS", "c2c.track_redis",
True, config_utils.config_bool):
try:
import redis.client
ORIG = redis.client.Redis.execute_command
redis.client.Redis.execute_command = _execute_command_patch # type: ignore
LOG.info("Enabled the redis tracking")
except Exception: # pragma: nocover # pylint: disable=broad-except
LOG.warning("Cannot enable redis tracking", exc_info=True)
def init_daemon(config: Optional[pyramid.config.Configurator] = None) -> None:
"""
Initialize the debug broadcast listeners.
Used mostly for headless processes that depend on a master providing a normal REST API and broadcasting
those requests.
"""
if config_utils.env_or_config(config,
ENV_KEY,
CONFIG_KEY,
type_=config_utils.config_bool):
from c2cwsgiutils.debug import _listeners
_listeners.init()
def includeme(config: Optional[pyramid.config.Configurator] = None) -> None:
"""Initialize the Sentry intergation."""
global _client_setup
sentry_url = config_utils.env_or_config(config, "SENTRY_URL",
"c2c.sentry.url")
if sentry_url is not None and not _client_setup:
client_info: MutableMapping[str, Any] = {
key[14:].lower(): value
for key, value in os.environ.items()
if key.startswith("SENTRY_CLIENT_")
}
# Parse bool
for key in (
"with_locals",
"default_integrations",
"send_default_pii",
"debug",
"attach_stacktrace",
"propagate_traces",
"auto_enabling_integrations",
"auto_session_tracking",
):
if key in client_info:
client_info[key] = client_info[key].lower() in ("1", "t",
"true")
# Parse int
for key in ("max_breadcrumbs", "shutdown_timeout",
"transport_queue_size"):
if key in client_info:
client_info[key] = int(client_info[key])
# Parse float
for key in ("sample_rate", "traces_sample_rate"):
if key in client_info:
client_info[key] = float(client_info[key])
git_hash = config_utils.env_or_config(config, "GIT_HASH",
"c2c.git_hash")
if git_hash is not None and not ("release" in client_info and
client_info["release"] != "latest"):
client_info["release"] = git_hash
client_info["ignore_errors"] = client_info.pop("ignore_exceptions",
"SystemExit").split(",")
tags = {
key[11:].lower(): value
for key, value in os.environ.items()
if key.startswith("SENTRY_TAG_")
}
sentry_logging = LoggingIntegration(
level=logging.DEBUG,
event_level=config_utils.env_or_config(config, "SENTRY_LEVEL",
"c2c.sentry_level",
"ERROR").upper(),
)
traces_sample_rate = float(
config_utils.env_or_config(config, "SENTRY_TRACES_SAMPLE_RATE",
"c2c.sentry_traces_sample_rate", "0.0"))
sentry_sdk.init(
dsn=sentry_url,
integrations=[
sentry_logging,
PyramidIntegration(),
SqlalchemyIntegration(),
RedisIntegration()
],
traces_sample_rate=traces_sample_rate,
before_send=_create_before_send_filter(tags),
**client_info,
)
_client_setup = True
excludes = config_utils.env_or_config(config, "SENTRY_EXCLUDES",
"c2c.sentry.excludes",
"sentry_sdk").split(",")
for exclude in excludes:
ignore_logger(exclude)
LOG.info("Configured sentry reporting with client=%s and tags=%s",
repr(client_info), repr(tags))
def is_enabled(config: pyramid.config.Configurator,
env_name: Optional[str] = None,
config_name: Optional[str] = None) -> bool:
"""Is the authentication enable."""
return (config_bool(env_or_config(config, env_name, config_name))
and auth_type(config.get_settings()) is not None)