def init(forkable=False): global sdk oneagent.initialize(forkable=forkable) state = oneagent.get_sdk().agent_state if state != oneagent.common.AgentState.ACTIVE: logger.warning( "Could not initialize the OneAgent SDK, AgentState: {}".format( state)) atexit.register(shutdown) sdk = oneagent.get_sdk()
def init(forkable=False): global sdk try: oneagent.initialize(forkable=forkable) except TypeError: # older versions of the oneagent SDK don't support forkable oneagent.initialize() state = oneagent.get_sdk().agent_state logger.debug("Initialized snidynatrace with AgentState: {}".format(state)) if state != oneagent.common.AgentState.ACTIVE: logger.warning( "Could not initialize the OneAgent SDK, AgentState: {}".format( state)) atexit.register(shutdown) sdk = oneagent.get_sdk()
def ListRecommendations(self, request, context): tag = '' for key, value in context.invocation_metadata(): if key == "x-dynatrace": tag = value incall = oneagent.get_sdk().trace_incoming_remote_call( 'ListRecommendations', 'RecommendationService', 'grpc://hipstershop.RecommendationService', protocol_name='gRPC', str_tag=tag) with incall: max_responses = 5 # fetch list of products from product catalog stub cat_response = product_catalog_stub.ListProducts(demo_pb2.Empty()) product_ids = [x.id for x in cat_response.products] filtered_products = list( set(product_ids) - set(request.product_ids)) num_products = len(filtered_products) num_return = min(max_responses, num_products) # sample list of indicies to return indices = random.sample(range(num_products), num_return) # fetch product ids from indices prod_list = [filtered_products[i] for i in indices] logger.info( "[Recv ListRecommendations] product_ids={}".format(prod_list)) # build and return response response = demo_pb2.ListRecommendationsResponse() response.product_ids.extend(prod_list) return response
def main(): call_msg = [] init_result = oneagent.initialize() if not init_result: print(init_result, file=sys.stderr) sys.exit(1) def diag_cb(msg): sys.stderr.flush() call_msg.append(msg) sdk = oneagent.get_sdk() try: sdk.set_diagnostic_callback(diag_cb) sdk.create_database_info(None, None, onesdk.Channel(0)) gc.collect() gc.collect() gc.collect() print(call_msg) n_msgs = len(call_msg) # Database name must not be null (from CSDK), leaked db info handle assert n_msgs == 2 assert all(isinstance(m, six.text_type) for m in call_msg) sdk.set_diagnostic_callback(None) sdk.create_database_info(None, None, onesdk.Channel(0)) print(call_msg[n_msgs:]) assert len(call_msg) == n_msgs finally: oneagent.shutdown()
def trace_incoming_message_process(opaque: Opaque, message: SQSMessage, queue_url: str): if not oneagent: yield else: try: queue_name = queue_url.split("/")[-1] except IndexError: queue_name = queue_url sdk = oneagent.get_sdk() messaging_system = sdk.create_messaging_system_info( AWS_SQS, queue_name, MessagingDestinationType.QUEUE, Channel(ChannelType.TCP_IP, None), ) tag = opaque.get(OPAQUE_TAG_KEY) request_id = opaque.get("X-Request-Id") with sdk.trace_incoming_message_process(messaging_system, str_tag=tag) as tracer: tracer.set_vendor_message_id(message.message_id) if request_id: tracer.set_correlation_id(request_id) yield
def prepare(self) -> None: self.trace = oneagent.get_sdk().trace_incoming_web_request( self.web_app_info, self.request.full_url(), self.request.method, self.request.headers, self.request.remote_ip, ) # トレーシング開始 self.trace.start()
def __init__(self): oneagent.initialize() if self.sdk is None: self.sdk = oneagent.get_sdk() if self. db_info is None: self.db_info = self.sdk.create_database_info('Polls', oneagent.sdk.DatabaseVendor.SQLITE, oneagent.sdk.Channel(oneagent.sdk.ChannelType.TCP_IP, '127.0.0.1:6666'))
def get_sdk(): oneagent.initialize() sdk = oneagent.get_sdk() if sdk.agent_state == 0: print("OneAgent initialized...") all_set = True else: print("OneAgent initialization failed...") print("Check that OneAgent is running...") all_set = False return all_set, sdk
def __init__(self, get_response): self.get_response = get_response oneagent.logger = logger if not oneagent.initialize(): logger.error('Error initialiing OneAgent SDK') else: self.sdk = oneagent.get_sdk() self.wappinfo = self.sdk.create_web_application_info( virtual_host='example.com', application_id='DjangoApp', context_root='/')
def Check(self, request, context): tag = '' for key, value in context.invocation_metadata(): if key == "x-dynatrace": tag = value incall = oneagent.get_sdk().trace_incoming_remote_call( 'Check', 'RecommendationService', 'grpc://hipstershop.RecommendationService', protocol_name='gRPC', str_tag=tag) with incall: return health_pb2.HealthCheckResponse( status=health_pb2.HealthCheckResponse.SERVING)
def trace_outgoing_message(topic_arn: str): if not oneagent: yield StubOutgoingTracer() else: sdk = oneagent.get_sdk() try: topic_name = topic_arn.split(":")[-1] except IndexError: topic_name = topic_arn messaging_system = sdk.create_messaging_system_info( AWS_SNS, topic_name, MessagingDestinationType.TOPIC, Channel(ChannelType.TCP_IP, None), ) with sdk.trace_outgoing_message(messaging_system) as tracer: yield tracer
def bench(): with oneagent.get_sdk().trace_incoming_remote_call('a', 'b', 'c'): tdf = 0 t_tot = 0 t_inner = None do_req = ur.AbstractHTTPHandler.do_request_ def wrap_req(self, req): nonlocal tdf req.host # pylint:disable=pointless-statement tdf += gtm() - t_inner return do_req(self, req) ur.AbstractHTTPHandler.do_request_ = wrap_req ur.HTTPHandler.http_request = wrap_req for _ in range(1): t_inner = gtm() ur.urlopen('http://localhost:8000/polls').close() t_tot += gtm() - t_inner return t_tot, tdf
def test_load_old_agent(): saved_path = os.environ.get('DT_AGENTLIBRARY', '') try: assert os.environ['DT_OLDAGENTLIBRARY'] is not None assert os.environ['DT_OLDAGENTLIBRARY'] != '' os.environ['DT_AGENTLIBRARY'] = os.environ.get('DT_OLDAGENTLIBRARY', '') sdk_options = oneagent.sdkopts_from_commandline(remove=True) init_result = oneagent.initialize(sdk_options) assert init_result.error is not None assert init_result.status == InitResult.STATUS_INIT_ERROR sdk = oneagent.get_sdk() assert sdk.agent_state == AgentState.NOT_INITIALIZED assert sdk.agent_found assert not sdk.agent_is_compatible assert sdk.agent_version_string == '1.141.246.20180604-140607/' + shipped_c_stub_version finally: oneagent.shutdown() os.environ['DT_AGENTLIBRARY'] = saved_path
def getdbinfo(): ''' Get Database Info ''' dbinfo = oneagent.get_sdk().create_database_info( 'flaskr.sqlite', oneagent.sdk.DatabaseVendor.SQLITE, oneagent.sdk.Channel(oneagent.sdk.ChannelType.IN_PROCESS)) return dbinfo
def initialize(self) -> None: self.web_app_info = oneagent.get_sdk().create_web_application_info( virtual_host='localhost', application_id='TornadoTutorialApp', context_root='/' )
import autodynatrace import oneagent import json from oneagent.common import DYNATRACE_HTTP_HEADER_NAME app = Flask("Dynatrace Support Lab Landing Page") init_result = oneagent.initialize() print('OneAgent SDK initialization result' + repr(init_result)) if init_result: print('SDK should work (but agent might be inactive).') else: print('SDK will definitely not work (i.e. functions will be no-ops):', init_result) sdk = oneagent.get_sdk() @autodynatrace.trace @app.route("/", methods=['GET']) def index(): with open('./configData.json') as json_configData: dict_configData = json.load(json_configData) return render_template("index.html", dict_configData=dict_configData) @app.route("/json", methods=['GET']) def json_text(): with open('./configData.json') as json_configData: return str(json_configData.read())
def wrapper(*args, **kwargs): with oneagent.get_sdk().trace_custom_service(function.__name__, function.__name__): with connection.execute_wrapper(dt): return function(*args, **kwargs)
def __call__(self, environ, start_response): # Extract HTTP headers from the WSGI environment header_keys = [] header_values = [] for key in environ: if key.startswith(HTTP_PREFIX): header_keys.append(cgi_to_http_name(key)) header_values.append(environ[key]) # Trace the web request vhost = environ.get('SERVER_NAME') or \ self.virtual_host or socket.gethostname() or 'localhost' ctxroot = environ.get('CONTEXT_PREFIX') or self.context_root or '/' with get_sdk().create_web_application_info( vhost, self.app_id, ctxroot) as wappinfo, \ get_sdk().trace_incoming_web_request( wappinfo, get_request_uri(environ), environ['REQUEST_METHOD'], headers=(header_keys, header_values)) as tracer: # Storage for the response information received by start_response last_response_info = [(None, None, (None, None))] # start_response is the function that is passed as an argument to # the WSGI application to receive information about the respose, # like headers and status_code. # In case of exceptions, start_response may be called multiple # times and the last call overrides previous ones. See # https://www.python.org/dev/peps/pep-3333/#the-start-response-callable # for details. def wrapped_start_response(status, response_headers, exc_info=None): # Record relevant parameters into the outer variable last_exc_info = exc_info[:2] if exc_info else None last_response_info[0] = ( status, response_headers, last_exc_info) # Call original start_response return start_response(status, response_headers, exc_info) # Put the tracer in the environment, mainly so that the called app # can use add_parameter on it if it wants to. environ['dynatrace.webrequest_tracer'] = tracer # Execute the actual application (it probably calls # wrapped_start_response in turn) result = self.app(environ, wrapped_start_response) # last_response_info should now contain the information from # start_response. See the XXX below for cases where we cannot have # that information here. last_status, last_headers, last_exc_info = last_response_info[0] if last_headers: for name, value in last_headers: #pylint:disable=not-an-iterable tracer.add_response_header(name, value) if last_status is not None: tracer.set_status_code( http_status_code_from_phrase_string(last_status)) if last_exc_info: tracer.mark_failed_exc(*last_exc_info) # XXX: Result is an iterable of bytestrings. This iterable could do the # actual heavy lifting in this webrequest, but we cannot instrument it # because the C SDK requires closing the handle on the same thread that # created it. However, it is nowhere guaranteed where the server # iterates over the result. # What is more, start_response may only be called in the first iteration # step of the iterable (e.g. if self.app is a generator function, # calling it does practically nothing), so in that worst case we get # basically ony the information about the incoming data but not # about the response (not even how long it really took to generate # the response. # In that cases, better tracing at risk of potentially reduced # performance and higher memory usage could be achieved by replacing # the line with `return list(result)`. Note that in the worst case, # that replacement may deadlock when the iterable waits for some # response before going on and the other side does the same. return result