def test_get_logger_default(self):
# set root logger to INFO level since the default logger will propagate to it
logging.basicConfig(level=logging.INFO)
logger = get_logger()
self.assertIsNotNone(logger)
self.assertEqual(logger.name, LOGGER_NAME)
self.assertEqual(logger.level, logging.INFO)
logger.info("Something bad happened")
self.assertEqual(logger, get_logger())
def test_get_logger_custom(self):
custom_logger = logging.getLogger("custom")
custom_logger.setLevel(logging.ERROR)
logger = get_logger(logger=custom_logger)
self.assertIsNotNone(logger)
self.assertEqual(logger.name, "custom")
self.assertEqual(logger.level, logging.ERROR)
logger.error("Something bad happened")
self.assertEqual(logger, get_logger())
def __init__(self, config, artifact):
"""
:param config: (target_decisioning_engine.types.decisioning_config.DecisioningConfig) config
:param artifact: (target_decisioning_engine.types.decisioning_artifact.DecisioningArtifact) artifact
"""
self.logger = get_logger()
self.pool_manager = urllib3.PoolManager()
self.config = config
self.artifact = artifact
self.geo_targeting_enabled = artifact.get("geoTargetingEnabled", False)
self.event_emitter = config.event_emitter or noop
def __init__(self, options):
"""TargetClient constructor"""
if not options or not options.get("internal"):
raise Exception(MESSAGES.get("PRIVATE_CONSTRUCTOR"))
self.config = dict(options)
self.config["timeout"] = options.get("timeout") if options.get("timeout") \
else DEFAULT_TIMEOUT
self.logger = get_logger(options.get("logger"))
self.event_emitter = EventProvider(self.config.get("events")).emit
self.decisioning_engine = None
def __init__(self,
request,
visitor,
send_notification_func=noop,
telemetry_enabled=True):
"""
:param request: (delivery_api_client.Model.delivery_request.DeliveryRequest) request
:param visitor: (delivery_api_client.Model.visitor_id.VisitorId) VisitorId instance
:param send_notification_func: (callable) function used to send the notification
:param telemetry_enabled: (bool) is telemetry enabled
"""
self.visitor = visitor
self.send_notification_func = send_notification_func
self.telemetry_enabled = telemetry_enabled
self.request = request
self.request_id = request.request_id
self.prev_event_keys = set()
self.notifications = []
self.telemetry_entries = []
self.logger = get_logger()
def __init__(self, config):
"""
:param config: (target_decisioning_engine.types.decisioning_config.DecisioningConfig)
Decisioning engine configuration
"""
self.pool_manager = urllib3.PoolManager()
self.http_retry = Retry(total=NUM_FETCH_RETRIES, backoff_factor=BACKOFF_FACTOR, status_forcelist=CODES_TO_RETRY)
self.config = config
self.logger = get_logger()
self.event_emitter = config.event_emitter or noop
self.polling_interval = None
self.artifact_location = None
self.polling_halted = False
self.polling_timer = None
self.artifact = None
self.subscriptions = {}
self.subscription_count = 0
self.last_response_etag = None
self.last_response_data = None
self.artifact_tracer = None
self.perf_tool = get_perf_tool_instance()
from target_decisioning_engine.types.decision_provider_response import DecisionProviderResponse
from target_decisioning_engine.utils import has_remote_dependency
from target_decisioning_engine.utils import get_rule_key
from target_decisioning_engine.notification_provider import NotificationProvider
from target_decisioning_engine.trace_provider import RequestTracer
from target_tools.utils import flatten_list
from target_tools.constants import DEFAULT_GLOBAL_MBOX
from target_tools.logger import get_logger
from target_tools.utils import get_property_token
from target_tools.perf_tool import get_perf_tool_instance
LOG_TAG = "{}.DecisionProvider".format(LOG_PREFIX)
PARTIAL_CONTENT = 206
OK = 200
logger = get_logger()
def order_by_name(obj):
"""Sort by name for MboxResponse and View"""
return obj.name
def order_by_event_token(metric):
"""Sort by event_token for Metric"""
return metric.event_token
class DecisionProvider:
"""DecisionProvider"""
