def test_scope_error_report(): tracer = Tracer() scope = tracer.start_active_span('foo') error_message = 'unexpected_situation' with mock.patch.object(scope.span, 'log_kv') as log_kv: with mock.patch.object(scope.span, 'set_tag') as set_tag: try: with scope: raise ValueError(error_message) except ValueError: pass assert set_tag.call_count == 1 assert set_tag.call_args[0] == (tags.ERROR, True) assert log_kv.call_count == 1 log_kv_args = log_kv.call_args[0][0] assert log_kv_args.get(logs.EVENT, None) is tags.ERROR assert log_kv_args.get(logs.MESSAGE, None) is error_message assert log_kv_args.get(logs.ERROR_KIND, None) is ValueError assert isinstance(log_kv_args.get(logs.ERROR_OBJECT, None), ValueError) assert isinstance(log_kv_args.get(logs.STACK, None), types.TracebackType)
def test_scope_manager(): # ensure the activation returns the noop `Scope` that is always active scope_manager = ScopeManager() span = Span(tracer=Tracer(), context=SpanContext()) scope = scope_manager.activate(span, False) assert scope == scope_manager._noop_scope assert scope == scope_manager.active
def test_scope_context_manager(): # ensure `Scope` can be used in a Context Manager that # calls the `close()` method span = Span(tracer=Tracer(), context=SpanContext()) scope = Scope(ScopeManager(), span) with mock.patch.object(scope, 'close') as close: with scope: pass assert close.call_count == 1
def test_scope_wrapper(): # ensure `Scope` wraps the `Span` argument span = Span(tracer=Tracer(), context=SpanContext()) scope = Scope(ScopeManager, span) assert scope.span == span
def __init__(self, cluster_or_uri=None, connect_timeout=30000, socket_timeout=300000, pool_size_per_route=10, pool_size_total=100, retry_count=3, tls_skip_verify=False, tls_ca_certificate_path="", use_manual_address=False, tracer=None): """Creates a Client. :param object cluster_or_uri: A ``pilosa.Cluster`` or ``pilosa.URI` instance :param int connect_timeout: The maximum amount of time in milliseconds to wait for a connection attempt to a server to succeed :param int socket_timeout: The maximum amount of time in milliseconds to wait between consecutive read operations for a response from the server :param int pool_size_per_route: Number of connections in the pool per server :param int pool_size_total: Total number of connections in the pool :param int retry_count: Number of connection trials :param bool tls_skip_verify: Do not verify the TLS certificate of the server (Not recommended for production) :param str tls_ca_certificate_path: Server's TLS certificate (Useful when using self-signed certificates) :param bool use_manual_address: Forces the client to use only the manual server address :param opentracing.tracer.Tracer tracer: Set the OpenTracing tracer. See: https://opentracing.io * See `Pilosa Python Client/Server Interaction <https://github.com/pilosa/python-pilosa/blob/master/docs/server-interaction.md>`_. """ self.use_manual_address = use_manual_address self.connect_timeout = connect_timeout / 1000.0 self.socket_timeout = socket_timeout / 1000.0 self.pool_size_per_route = pool_size_per_route self.pool_size_total = pool_size_total self.retry_count = retry_count self.tls_skip_verify = tls_skip_verify self.tls_ca_certificate_path = tls_ca_certificate_path self.__current_host = None self.__client = None self.logger = logging.getLogger("pilosa") self.__coordinator_lock = threading.RLock() self.__coordinator_uri = None self.tracer = tracer or Tracer() if cluster_or_uri is None: self.cluster = Cluster(URI()) elif isinstance(cluster_or_uri, Cluster): self.cluster = cluster_or_uri.copy() elif isinstance(cluster_or_uri, URI): if use_manual_address: self.__coordinator_uri = cluster_or_uri self.__current_host = cluster_or_uri else: self.cluster = Cluster(cluster_or_uri) elif isinstance(cluster_or_uri, str): uri = URI.address(cluster_or_uri) if use_manual_address: self.__coordinator_uri = uri self.__current_host = uri else: self.cluster = Cluster(uri) else: raise PilosaError("Invalid cluster_or_uri: %s" % cluster_or_uri)