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)