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
