def test_tracer_context_provider_config(self):
tracer = ddtrace.opentracer.Tracer("mysvc",
scope_manager=GeventScopeManager())
assert isinstance(
tracer._dd_tracer.context_provider,
ddtrace.contrib.gevent.provider.GeventContextProvider,
)
def test_trace_spawn_multiple_greenlets_multiple_traces_ot(self):
"""OpenTracing version of the same test."""
ot_tracer = init_tracer("my_svc", self.tracer, scope_manager=GeventScopeManager())
def entrypoint():
with ot_tracer.start_active_span("greenlet.main") as span:
span.resource = "base"
jobs = [gevent.spawn(green_1), gevent.spawn(green_2)]
gevent.joinall(jobs)
def green_1():
with self.tracer.trace("greenlet.worker1") as span:
span.set_tag("worker_id", "1")
gevent.sleep(0.01)
# note that replacing the `tracer.trace` call here with the
# OpenTracing equivalent will cause the checks to fail
def green_2():
with ot_tracer.start_active_span("greenlet.worker2") as scope:
scope.span.set_tag("worker_id", "2")
gevent.sleep(0.01)
gevent.spawn(entrypoint).join()
spans = self.tracer.writer.pop()
self._assert_spawn_multiple_greenlets(spans)
def instrument_gevent():
""" Adds context propagation to gevent greenlet spawning """
try:
logger.debug("Instrumenting gevent")
import gevent
from opentracing.scope_managers.gevent import GeventScopeManager
from opentracing.scope_managers.gevent import _GeventScope
def spawn_callback(new_greenlet):
""" Handles context propagation for newly spawning greenlets """
parent_scope = tracer.scope_manager.active
if parent_scope is not None:
# New greenlet, new clean slate. Clone and make active in this new greenlet
# the currently active scope (but don't finish() the span on close - it's a
# clone/not the original and we don't want to close it prematurely)
# TODO: Change to our own ScopeManagers
parent_scope_clone = _GeventScope(parent_scope.manager, parent_scope.span, finish_on_close=False)
tracer._scope_manager._set_greenlet_scope(parent_scope_clone, new_greenlet)
logger.debug(" -> Updating tracer to use gevent based context management")
tracer._scope_manager = GeventScopeManager()
gevent.Greenlet.add_spawn_callback(spawn_callback)
except:
logger.debug("instrument_gevent: ", exc_info=True)
def ot_tracer(ot_tracer_factory):
"""Fixture providing an opentracer configured for gevent usage."""
# patch gevent
patch()
yield ot_tracer_factory("gevent_svc", {}, GeventScopeManager(), ddtrace.contrib.gevent.context_provider)
# unpatch gevent
unpatch()
def setUp(self):
self.http = urllib3.HTTPConnectionPool('127.0.0.1',
port=testenv["wsgi_port"],
maxsize=20)
self.recorder = tracer.recorder
self.recorder.clear_spans()
tracer._scope_manager = GeventScopeManager()
def setUp(self):
self.tracer = MockTracer(GeventScopeManager())
def scope_manager(self):
return GeventScopeManager()
def test_get_context_provider_for_scope_manager_asyncio(self):
scope_manager = GeventScopeManager()
ctx_prov = get_context_provider_for_scope_manager(scope_manager)
assert isinstance(
ctx_prov, ddtrace.contrib.gevent.provider.GeventContextProvider)
def setUp(self):
self.tracer = MockTracer(GeventScopeManager())
self.queue = gevent.queue.Queue()
self.server = Server(tracer=self.tracer, queue=self.queue)
def main( # pylint: disable=too-many-arguments,too-many-locals
private_key: PrivateKey,
state_db: str,
web3: Web3,
contracts: Dict[str, Contract],
start_block: BlockNumber,
confirmations: BlockTimeout,
host: str,
port: int,
service_fee: TokenAmount,
operator: str,
info_message: str,
enable_debug: bool,
matrix_server: List[str],
accept_disclaimer: bool,
enable_tracing: bool,
tracing_sampler: str,
tracing_param: str,
) -> int:
"""The Pathfinding service for the Raiden Network."""
log.info("Starting Raiden Pathfinding Service")
click.secho(PFS_DISCLAIMER, fg="yellow")
if not accept_disclaimer:
click.confirm(CONFIRMATION_OF_UNDERSTANDING, abort=True)
if not confirmations:
chain_id = ChainID(web3.eth.chain_id)
confirmations = (BlockTimeout(0) if "arbitrum" in ID_TO_CHAINNAME.get(
chain_id, "") else DEFAULT_NUMBER_OF_BLOCK_CONFIRMATIONS)
log.info("Setting number of confirmation blocks",
confirmations=confirmations)
log.info("Using RPC endpoint", rpc_url=get_web3_provider_info(web3))
hex_addresses = {
name: to_checksum_address(contract.address)
for name, contract in contracts.items()
}
log.info("Contract information",
addresses=hex_addresses,
start_block=start_block)
if enable_tracing:
tracing_config = Config(
config={
"sampler": {
"type": tracing_sampler,
"param": tracing_param
},
"logging": True
},
service_name="pfs",
scope_manager=GeventScopeManager(),
validate=True,
)
# Tracer is stored in `opentracing.tracer`
tracing_config.initialize_tracer()
assert isinstance(web3.provider, HTTPProvider), MYPY_ANNOTATION
assert web3.provider.endpoint_uri is not None, MYPY_ANNOTATION
# Set `Web3` requests Session to use `SessionTracing`
cache_session(
web3.provider.endpoint_uri,
SessionTracing(propagate=False, span_tags={"target": "ethnode"}),
)
service = None
api = None
try:
service = PathfindingService(
web3=web3,
contracts=contracts,
sync_start_block=start_block,
required_confirmations=confirmations,
private_key=private_key,
poll_interval=DEFAULT_POLL_INTERVALL,
db_filename=state_db,
matrix_servers=matrix_server,
enable_tracing=enable_tracing,
)
service.start()
log.debug("Waiting for service to start before accepting API requests")
try:
service.startup_finished.get(timeout=PFS_START_TIMEOUT)
except gevent.Timeout:
raise Exception("PFS did not start within time.")
log.debug("Starting API")
api = PFSApi(
pathfinding_service=service,
service_fee=service_fee,
debug_mode=enable_debug,
one_to_n_address=to_canonical_address(
contracts[CONTRACT_ONE_TO_N].address),
operator=operator,
info_message=info_message,
enable_tracing=enable_tracing,
)
api.run(host=host, port=port)
service.get()
except (KeyboardInterrupt, SystemExit):
print("Exiting...")
finally:
log.info("Stopping Pathfinding Service...")
if api:
api.stop()
if service:
service.stop()
return 0
def setUp(self):
self.tracer = MockTracer(GeventScopeManager())
self.client = Client(RequestHandler(self.tracer))