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__(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(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 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 __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 main(): # This gathers arguments prefixed with '--dt_' from sys.argv into the # returned list. See also the basic-sdk-sample. sdk_options = oneagent.sdkopts_from_commandline(remove=True) # Before using the SDK you have to initialize the OneAgent. In this scenario, we # initialize the SDK and prepare it for forking. # # Passing in the sdk_options is entirely optional and usually not required # as all settings will be automatically provided by the Dynatrace OneAgent # that is installed on the host. # # To activate the forking support add the optional 'forkable' parameter and set it to True. # # If you run this example on Windows then you'll get an "Invalid Argument" error back # because there's no forking support for Windows available. init_result = oneagent.initialize(sdk_options, forkable=True) try: if init_result.error is not None: print('Error during SDK initialization:', init_result.error) # While not by much, it is a bit faster to cache the result of # oneagent.get_sdk() instead of calling the function multiple times. sdk = getsdk() # The agent state is one of the integers in oneagent.sdk.AgentState. # Since we're using the 'forkable' mode the state will be TEMPORARILY_INACTIVE (1) on Linux. print('Agent state (parent process):', sdk.agent_state) # In the parent, the state will be PARENT_INITIALIZED (1). print('Agent fork state (parent process):', sdk.agent_fork_state) # The instance attribute 'agent_found' indicates whether an agent could be found or not. print('Agent found:', sdk.agent_found) # If an agent was found but it is incompatible with this version of the SDK for Python # then 'agent_is_compatible' would be set to false. print('Agent is compatible:', sdk.agent_is_compatible) # The agent version is a string holding both the OneAgent version and the # OneAgent SDK for C/C++ version separated by a '/'. print('Agent version:', sdk.agent_version_string) if init_result.error is None: fork_children() input('Now wait until the path appears in the UI ...') finally: shutdown_error = oneagent.shutdown() if shutdown_error: print('Error shutting down SDK:', shutdown_error)
def main(): signal.signal(signal.SIGTERM, shutdown_handler) signal.signal(signal.SIGINT, shutdown_handler) logging.basicConfig(level=logging.DEBUG) logger = logging.getLogger() logger.setLevel(logging.INFO) logger.addFilter(LogLevelCountFilter()) init_result = oneagent.initialize() if init_result.status is not InitResult.STATUS_INITIALIZED: logging.error(f'Error initializing OneAgent SDK. ' f'status = {init_result.status}, ' f'error = {init_result.error}') app = tornado.web.Application([ (r'/test', TestHandler), (r'/metrics', MetricsHandler), ]) app.listen(8080) tornado.ioloop.IOLoop.current().start()
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 main(): import logging logger = logging.getLogger('py_sdk') logger.addHandler(logging.StreamHandler()) logger.setLevel(logging.DEBUG) flags = sys.argv[1].split() if len(sys.argv) > 1 else () if 'noc' in flags: sys.modules['oneagent._impl.native.sdkctypesiface'] = False if 'tryinit' in flags: init_result = oneagent.initialize(['loglevelsdk=finest']) if 'noc' in flags: assert not init_result assert init_result.status == init_result.STATUS_STUB_LOAD_ERROR assert isinstance(init_result.error, ImportError) else: assert init_result assert init_result.status == init_result.STATUS_INITIALIZED from test import onesdksamplepy onesdksamplepy.main() print('DONE.')
def sdk_init(): ''' Initialize OneAgent Python SDK ''' sdk_options = oneagent.sdkopts_from_commandline(remove=True) init_result = oneagent.initialize(sdk_options) if init_result: print('SDK should work (but agent might be inactive).', file=sys.stderr) else: print( 'SDK will definitely not work (i.e. functions will be no-ops); init_result =', init_result, file=sys.stderr) return False try: getsdk().set_diagnostic_callback(_diag_callback) finally: print('Agent state:', getsdk().agent_state, file=sys.stderr) print('Agent found:', getsdk().agent_found, file=sys.stderr) print('Agent is compatible:', getsdk().agent_is_compatible, file=sys.stderr) print('Agent version:', getsdk().agent_version_string, file=sys.stderr) return True
'PRODUCT_CATALOG_SERVICE_ADDR environment variable not set') logger.info("product catalog address: " + catalog_addr) channel = grpc.insecure_channel(catalog_addr) product_catalog_stub = demo_pb2_grpc.ProductCatalogServiceStub(channel) # create gRPC server server = grpc.server(futures.ThreadPoolExecutor(max_workers=10), interceptors=(tracer_interceptor, )) # add class to gRPC server service = RecommendationService() demo_pb2_grpc.add_RecommendationServiceServicer_to_server(service, server) health_pb2_grpc.add_HealthServicer_to_server(service, server) #init oneagent if not oneagent.initialize(['loglevelsdk=finest', 'loglevel=finest']): print('Error initializing OneAgent SDK.') # start server logger.info("listening on port: " + port) server.add_insecure_port('[::]:' + port) server.start() # keep alive try: while True: time.sleep(10000) except KeyboardInterrupt: server.stop(0) oneagent.shutdown()
def main(): print('+main') # This gathers arguments prefixed with '--dt_' from sys.argv into the # returned list. See initialize below. sdk_options = oneagent.sdkopts_from_commandline(remove=True) # Before using the SDK you have to initialize the OneAgent. You can call oneagent.initialize() # as often as you want, but you also have to call oneagent.shutdown() for every call to # initialize() as well. # # Passing in the sdk_options is entirely optional and usually not required # as all settings will be automatically provided by the Dynatrace OneAgent # that is installed on the host. init_result = oneagent.initialize(sdk_options) try: if init_result.error is not None: print('Error during SDK initialization:', init_result.error) # While not by much, it is a bit faster to cache the result of # oneagent.get_sdk() instead of calling the function multiple times. sdk = getsdk() # Set the diagnostic callback. Strongly recommended. sdk.set_diagnostic_callback(_diag_callback) # Set the verbose callback. # Not recommended in production as lots of messages can be emitted. if IN_DEV_ENVIRONMENT: sdk.set_verbose_callback(_diag_callback) # The agent state is one of the integers in oneagent.sdk.AgentState. print('Agent state:', sdk.agent_state) # The instance attribute 'agent_found' indicates whether an agent could be found or not. print('Agent found:', sdk.agent_found) # If an agent was found but it is incompatible with this version of the SDK for Python # then 'agent_is_compatible' would be set to false. print('Agent is compatible:', sdk.agent_is_compatible) # The agent version is a string holding both the OneAgent version and the # OneAgent SDK for C/C++ version separated by a '/'. print('Agent version:', sdk.agent_version_string) mock_incoming_web_request() mock_outgoing_web_request() mock_outgoing_message() mock_custom_service() # We use trace_incoming_remote_call here, because it is one of the few # calls that create a new path if none is running yet. with sdk.trace_incoming_remote_call('main', 'main', 'main'): # We want to start an asynchronous execution at this time, so we create an # in-process link which we will use afterwards (or in a different thread). link = sdk.create_in_process_link() # Simulate some remote calls outgoing_remote_call(success=True) outgoing_remote_call(success=True) outgoing_remote_call(success=False) # Now the asynchronous execution starts. So we create an in-process tracer. We're using # the in-process link which we've created above. This link specifies where the traced # actions below will show up in the path. with sdk.trace_in_process_link(link): outgoing_remote_call(success=True) print('-main') input('Now wait until the path appears in the UI...') finally: shutdown_error = oneagent.shutdown() if shutdown_error: print('Error shutting down SDK:', shutdown_error)
from flask import * 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())
from timeit import default_timer as gtm import oneagent 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 if __name__ == '__main__': oneagent.initialize() t_total, t_diff = bench() oneagent.shutdown() print(t_total, t_diff, t_diff / t_total)