Package: oneagent-sdk
Read the latest version of this README, with working internal links, atGitHub.Dynatrace OneAgent SDK for PythonThis SDK enables Dynatrace customers to extend request level visibility into Python applications. It provides the Python implementation of theDynatrace OneAgent SDK.For the latest updates, seeRelease notes and announcementsand make sure you are reading thelatest version of this document.RequirementsUsing the OneAgent SDK for Python in your applicationAPI ConceptsInitialization and SDK objectsTracersFeatures and how to use themRemote callsSQL database requestsIncoming web requestsOutgoing web requestsTrace in-process asynchronous executionCustom Request AttributesCustom servicesMessagingOutgoing MessagesIncoming MessagesW3C trace contextUsing the OneAgent SDK for Python with forked child processes (only available on Linux)TroubleshootingExtended SDK StateShutdown crashesRepository contentsHelp & SupportRead the manualLet us help youRelease notes and announcementsAnnouncements in November 2023Version 1.5.1Version 1.5.0LicenseRequirementsThe latest release of the SDK supports Python 3 only, see below for exact support status of Python versions.Only the official CPython (that is, the "normal" Python, i.e. the Python implementation
fromhttps://python.org) is supported and only on Linux (musl libc which is used, e.g., on Alpine Linux, is currently not supported)
and Windows with the x86 (including x86-64) architecture.
It is always advised to use the latest patch version of your minor versoin of Python, as these usually contain security
fixes and other important bugfixes.Additionally,pipwith thewheelandsetuptoolspackage installed is required for installation,
and on Linux, the system needs to bemanylinux1-compatible.pipversions before 8.1.0 are known not to work, but generally it is advised to always use the latest pip version.
Due to factors such as changes in package hosting by PyPI and Python itself,
Dynatrace cannot guarantee that SDK installation is, or will continue to be,
possible with old pip versions.The Dynatrace OneAgent SDK for Python is a wrapper of theDynatrace OneAgent SDK for C/C++and therefore the SDK for C/C++ is required and delivered with the Python SDK. Seeherefor its requirements, which also apply to the SDK for Python.The version of the SDK for C/C++ that is included in each version of the SDK for Python is shown in the following table along with the required
Dynatrace OneAgent version (it is the same aslisted in the OneAgent SDK for C/C++'s documentation).Note: The OneAgent SDK is not supported on serverless code modules, including those for AWS Lambda.
Consider usingOpenTelemetryinstead in these scenarios.OneAgent SDK for PythonBundled OneAgent SDK for C/C++Required OneAgentRequired PythonSupport status1.5.x1.7.1≥1.251≥3.5🟢 Supported1.4.x1.6.1≥1.1793.4.x-3.11.xℹ️ Deprecated with support ending 2024-06-011.3.x1.5.1≥1.1792.7.x or 3.4.x-3.11.x❌ Unsupported since 2023-07-011.2.x1.4.1≥1.1612.7.x or 3.4.x-3.11.x❌ Unsupported since 2023-07-011.1.x1.3.1≥1.1512.7.x or 3.4.x-3.11.x❌ Unsupported since 2023-07-011.0.x1.1.0≥1.1412.7.x or 3.4.x-3.11.x❌ Unsupported since 2023-07-01Note that this table only states the support status of the mentioned OneAgent SDK for Python version
with the included OneAgent SDK for C/C++, not the OneAgent itself.The "required Python" column indicates the Python versions with which the SDK version was developed and tested (where marked with *,
the minimum version has been updated to adjust for Python deprecations from the table below).
We may additionally announce deprecations for older versions of Python in combination with specific or all versions of the SDK,
meaning that we will no longer provide support for these combinations after the given date, even if the SDK version itself
is supported and technically running on that Python version.
We also strongly advise against using Python versions that are no longer supported by your Python vendor.We intend to deprecate Python versions effective around 6 months after the Python project stops supporting them as documented by the
Python project:https://devguide.python.org/versions/. We will announce every deprecation explicitly, usually 6 months before
it becomes effective.Python versionDeprecation statusAny later 3.x🟢 Supported unless announced otherwise. Pre-releases are not supported.3.8.x🟢 Supported. Expected to be deprecated with support ending around May 20253.7.x⚠️ Deprecated with SDK support ending 2024-09-01; Declared EOL by Python.org3.4.x-3.6.x⚠️ Deprecated with SDK support (with compatible SDK versions) ending 2024-06-01; Declared EOL by Python.org2.7.x❌ Unsuspported since 2023-07-01Using the OneAgent SDK for Python in your applicationTo install the latest version of the OneAgent SDK for Python, use the PyPI packageoneagent-sdk:python-mpipinstall--upgradeoneagent-sdkpip,setuptoolsandwheelneed to be installed and should be up to date before running this command.To verify your installation, executepython-c"import oneagent; print(oneagent.initialize())"If the installation was successful, you should get an output ending withInitResult(status=0, error=None). Otherwise, see theTroubleshootingsection.To load the OneAgent SDK into your application, just add the following line at the top of your script:importoneagentHere is a quick "Hello World" that will produce a service call in Dynatrace:importoneagentifnotoneagent.initialize():print('Error initializing OneAgent SDK.')withoneagent.get_sdk().trace_incoming_remote_call('method','service','endpoint'):passprint('It may take a few moments before the path appears in the UI.')input('Please wait...')oneagent.shutdown()A more detailedsample application is available here.
See also the Quickstart section in theAPI documentation.API ConceptsCommon concepts of the Dynatrace OneAgent SDK are explained in theDynatrace OneAgent SDK repository.Initialization and SDK objectsBefore first using any other SDK functions, you need to initialize the SDK.init_result=oneagent.initialize()print('OneAgent SDK initialization result'+repr(init_result))ifinit_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)See the API documentation for theinitializefunctionand theInitResultclassfor more information.To use the SDK, get a reference to theSDKsingleton by calling the oneagent staticget_sdkmethod. The first thing you may want to do with this object, is checking if the agent is active by comparing the value of theagent_stateproperty to theoneagent.common.AgentStateconstants. You can also have a look at theextended SDK state information.importoneagentfromoneagent.commonimportAgentState# Initialize oneagent, as abovesdk=oneagent.get_sdk()ifsdk.agent_statenotin(AgentState.ACTIVE,AgentState.TEMPORARILY_INACTIVE):print('Too bad, you will not see data from this process.')As a development and debugging aid it is recommended to set a diagnostic callback. The callback will be used by the SDK to inform about unusual events.Unusual events that prevent an operation from completing successfully include:API usage errorsother unexpected events (like out of memory situations)NOTE: Use this as a development and debugging aid only. Your application should not rely on a calling sequence or any message content being set
or passed to the callback.During development, it is additionally recommended to use the "verbose callback" which also informs about other events that may be benign
but can be very helpful in debugging, e.g. a PurePath that was not created because a Tracer is disabled by configuration, etc.def_diag_callback(unicode_message):print(unicode_message)sdk.set_diagnostic_callback(_diag_callback)sdk.set_verbose_callback(_diag_callback)# Do not use this callback in productionTracersTo trace any kind of call you first need to create aTracer,
using one of the varioustrace_*methods of theSDKobject. The Tracer object controls the “life cycle” of a trace: Entering awith-block with a tracer starts the trace, exiting it ends it. Exiting thewithblock with an exception causes the trace to be marked as failed with the
exception message (if you do not want or need this behavior, tracers have
explicit methods for starting, ending and attaching error information too; see thedocumentation).A Tracer instance can only be used from the thread on which it was created.
Whenever you start a tracer, the tracer becomes a child of the previously active tracer
on this thread and the new tracer then becomes the active tracer. You may only end the active tracer.
If you do, the tracer that was active before it (its parent) becomes active again.
Put another way, tracers must be ended in reverse order of starting them
(you can think of this being like HTML tags where you must also close the child tag before you can close the parent tag).
While the tracer's automatic parent-child relationship works very intuitively in most cases,
it does not work withasynchronous patterns, where the same thread handles multiple logically
separate operations in an interleaved way on the same thread. If you need to instrument
such patterns with the SDK, you need to end your tracer before the thread is potentially reused
by any other operation (e.g., before yielding to the event loop). To later continue the trace,
capture an in-process link before and later resume using the in-process link tracer, as explained inTrace in-process asynchronous execution. This approach is rather awkward and
may lead to complex and difficult to interpret traces. If your application makes extensive use of
asynchronous patterns of the kind that is difficult to instrument with the SDK, consider using
theOpenTelemetry support of Dynatraceinstead.There are different tracer types requiring different information for creation.
As an example, to trace an incoming remote call, this would be the most simple
way to trace it:importoneagentwithoneagent.get_sdk().trace_incoming_remote_call('method','service','endpoint'):pass# Here you would do the actual work that is timedSee the section onremote callsfor more information.Some tracers also support attaching additional information before ending it.Important:In Python 2, tracers accept both byte (“normal”) and unicode
strings. Byte strings must always use the UTF-8 encoding!Features and how to use themThe feature sets differ slightly with each language implementation. More functionality will be added over time, seePlanned features for OneAgent SDKfor details on upcoming features.A more detailed specification of the features can be found inDynatrace OneAgent SDK.FeatureRequired OneAgent SDK for Python versionW3C trace context for log enrichment≥1.5.0Custom services≥1.2.0Messaging≥1.2.0In-process linking≥1.1.0Custom request attributes≥1.1.0Outgoing web requests≥1.1.0Incoming web requests≥1.0.0SQL database requests≥1.0.0Trace incoming and outgoing remote calls≥1.0.0Remote callsYou can use the SDK to trace communication from one process to another. This will enable you to see full Service Flow, PurePath and Smartscape topology
for remoting technologies that Dynatrace is not aware of.To trace any kind of remote call you first need to create a Tracer. The Tracer object represents the endpoint that you want to call, thus you need to
supply the name of the remote service and method. In addition, you need to transport a tag in your remote call from the client side to the server side
if you want to trace it end to end.On the client side, you would trace the outgoing remote call like this:outcall=sdk.trace_outgoing_remote_call('remoteMethodToCall','RemoteServiceName','rmi://Endpoint/service',oneagent.sdk.Channel(oneagent.sdk.ChannelType.TCP_IP,'remoteHost:1234'),protocol_name='RMI/custom')withoutcall:# Note: You can access outgoing_dynatrace_*_tag only after the trace# has started!strtag=outcall.outgoing_dynatrace_string_tagdo_actual_remote_call(extra_headers={'X-dynaTrace':strtag})On the server side, you would trace it like this:incall=sdk.trace_incoming_remote_call('remoteMethodToCall','RemoteServiceName','rmi://Endpoint/service',protocol_name='RMI/custom',str_tag=my_remote_message.get_header_optional('X-dynaTrace'))withincall:pass# Here you would do the actual work that is timedSee the documentation for more information:trace_incoming_remote_calltrace_outgoing_remote_callGeneral information on taggingSQL database requestsTo trace database requests you need a database info object which stores the information about your database which does not change between individual
requests. This will typically be created somewhere in your initialization code (after initializing the SDK):dbinfo=sdk.create_database_info('Northwind',oneagent.sdk.DatabaseVendor.SQLSERVER,oneagent.sdk.Channel(oneagent.sdk.ChannelType.TCP_IP,'10.0.0.42:6666'))Then you can trace the SQL database requests:withsdk.trace_sql_database_request(dbinfo,'SELECT foo FROM bar;')astracer:# Do actual DB requesttracer.set_rows_returned(42)# Optionaltracer.set_round_trip_count(3)# OptionalNote that you need to release the database info object. You can do this by callingclose()on it or using it in awithblock.See the documentation for more information:create_database_infotrace_sql_database_requestDatabaseRequestTracerPlease note that SQL database traces are only created if they occur within some other SDK trace (e.g. incoming remote call).Incoming web requestsSame as with database infos, to trace incoming web requests you need a web application info object which stores the
information about your web application which does not change:wappinfo=sdk.create_web_application_info(virtual_host='example.com',application_id='MyWebApplication',context_root='/my-web-app/')Then you can trace incoming web requests:wreq=sdk.trace_incoming_web_request(wappinfo,'http://example.com/my-web-app/foo?bar=baz','GET',headers={'Host':'example.com','X-foo':'bar'},remote_address='127.0.0.1:12345')withwreq:wreq.add_parameter('my_form_field','1234')# Process web requestwreq.add_response_headers({'Content-Length':'1234'})wreq.set_status_code(200)# OKNote that you need to release the web application info object. You can do this by callingclose()on it or using it in awithblock.Incoming web request tracers support some more features not shown here. Be sure to check out the documentation:create_web_application_infotrace_incoming_web_requestIncomingWebRequestTracerOutgoing web requestsTo trace an outgoing web request you need to create an 'Outgoing Web Request Tracer' object. You pass the destination URL, the HTTP method and
request headers as parameters.Let's have a look at a web request example:fromurllib.requestimportRequest# Create your web request.url='http://example.com'req=Request(url)req.add_header('header1','1234')req.add_header('header2','5678')After creating/setting up the request you have to create the tracer object and pass the parameters.# Create the tracer.tracer=sdk.trace_outgoing_web_request(url,req.get_method(),req.headers)The next step is to start the tracer and then to retrieve the outgoing Dynatrace tag. The tag is being used to trace a transaction from end-to-end.
You have to send the tag to the destination via an additional request header which is calledDYNATRACE_HTTP_HEADER_NAME.Here you can find more information on tagging.withtracer:# Get and set the Dynatrace tag.tag=tracer.outgoing_dynatrace_string_tagreq.add_header(DYNATRACE_HTTP_HEADER_NAME,tag)# Here you process and send the web request.response=_process_your_outgoing_request(req)Finally, get the response headers you want to trace and the status code of the response and add them to the tracer.tracer.add_response_headers({'Content-Length':response.get_content_length()})tracer.set_status_code(response.get_status_code())Be sure to check out the documentation:trace_outgoing_web_requestOutgoingWebRequestTracerGeneral information on taggingTrace in-process asynchronous executionYou can use the SDK to trace asynchronous in-process code execution. This might be useful if the OneAgent does not support the threading framework
or specific asynchronous libraries. In-process linking should be used to link other services (Database, Webrequests, ...) between thread or
queueing boundaries currently not supported out-of-the-box by the OneAgent.To link asynchronous execution, you need to create an in-process link, where the execution forks:in_process_link=sdk.create_in_process_link()The provided in-process link must not be serialized and can only be used inside the process in which it was created. It must be used to start
tracing where the asynchronous execution takes place:withsdk.trace_in_process_link(in_process_link):# Do the asynchronous job:Custom Request AttributesYou can use the SDK to add custom request attributes to the currently traced service. Custom request attributes allow you to do easier/better
filtering of your requests in Dynatrace.Adding custom request attributes to the currently traced service call is pretty simple. Just call theadd_custom_request_attributemethod
with your key and value (only int, float and string values are currently supported):sdk.add_custom_request_attribute('errorCount',42)sdk.add_custom_request_attribute('gross weight',2.39)sdk.add_custom_request_attribute('famous actor','Benedict Cumberbatch')Check out the documentation at:add_custom_request_attributeCustom servicesYou can use the SDK to trace custom service methods. A custom service method is a meaningful part
of your code that you want to trace but that does not fit any other tracer. An example could be
the callback of a periodic timer.withsdk.trace_custom_service('onTimer','CleanupTask'):# Do the cleanup taskCheck out the documentation at:trace_custom_serviceMessagingYou can use the SDK to trace messages sent or received via a messaging system. When tracing messages,
we distinguish between:sending a messagewaiting for and receiving a messageprocessing a received messageOutgoing MessagesAll messaging related tracers need a messaging system info object which you have to create prior
to the respective messaging tracer, which is an outgoing message tracer in the example below.msi_handle=sdk.create_messaging_system_info('myMessagingSystem','requestQueue',MessagingDestinationType.QUEUE,oneagent.sdk.Channel(oneagent.sdk.ChannelType.TCP_IP,'10.11.12.13'))withmsi_handle:withsdk.trace_outgoing_message(msi_handle)astracer:# Get and set the Dynatrace tag.tag=tracer.outgoing_dynatrace_string_tagmessage_to_send.add_header_field(oneagent.sdk.DYNATRACE_MESSAGE_PROPERTY_NAME,tag)# Send the message.the_queue.send(message_to_send)# Optionally set message and/or correlation IDstracer.set_vendor_message_id(message_to_send.get_message_id())tracer.set_correlation_id(message_to_send.get_correlation_id())Incoming MessagesOn the incoming side, we need to differentiate between the blocking receiving part and processing
the received message. Therefore two different tracers are being used:IncomingMessageReceiveTracerIncomingMessageProcessTracermsi_handle=sdk.create_messaging_system_info('myMessagingSystem','requestQueue',MessagingDestinationType.QUEUE,oneagent.sdk.Channel(oneagent.sdk.ChannelType.TCP_IP,'10.11.12.13'))withmsi_handle:# Create the receive tracer for incoming messages.withsdk.trace_incoming_message_receive(msi_handle):# This is a blocking call, which will return as soon as a message is available.Messagequery_message=the_queue.receive()# Get the Dynatrace tag from the message.tag=query_message.get_header_field(oneagent.sdk.DYNATRACE_MESSAGE_PROPERTY_NAME)# Create the tracer for processing incoming messages.tracer=sdk.trace_incoming_message_process(msi_handle,str_tag=tag)tracer.set_vendor_message_id(query_message.get_vendor_id())tracer.set_correlation_id(query_message.get_correlation_id())withtracer:# Now let's handle the message ...print('handle incoming message')In case of non-blocking receive (e. g. using an event handler), there is no need to use an
IncomingMessageReceiveTracer - just trace processing of the message by using the IncomingMessageProcessTracer:msi_handle=sdk.create_messaging_system_info('myMessagingSystem','requestQueue',MessagingDestinationType.QUEUE,oneagent.sdk.Channel(oneagent.sdk.ChannelType.TCP_IP,'10.11.12.13'))defon_message_received(message):# Get the Dynatrace tag from the message.tag=message.get_header_field(oneagent.sdk.DYNATRACE_MESSAGE_PROPERTY_NAME)# Create the tracer for processing incoming messages.tracer=sdk.trace_incoming_message_process(msi_handle,str_tag=tag)tracer.set_vendor_message_id(message.get_vendor_id())tracer.set_correlation_id(message.get_correlation_id())withtracer:# Now let's handle the message ...print('handle incoming message')See the documentation for more information:create_messaging_system_infotrace_outgoing_messagetrace_incoming_message_receivetrace_incoming_message_processGeneral information on taggingMessaging tracers in the specification repositoryW3C trace contextThis feature allows you to retrieve a W3C TraceContext trace ID and span ID referencing the current PurePath node,
as defined inhttps://www.w3.org/TR/trace-context.This trace ID and span ID information is not intended for tagging and
context-propagation scenarios and primarily designed for log-enrichment use
cases. Refer toGeneral information on taggingfor tagging traces (see also the usage examples elsewhere in this document).The following example shows how to print the current trace & span ID to stdout
in a format that works well with Dynatrace Log Monitoring
(seehttps://www.dynatrace.com/support/help/shortlink/log-monitoring-log-enrichmentfor more):withsdk.trace_custom_service('onTimer','CleanupTask'):# Or any other tracertinfo=sdk.tracecontext_get_current()print('[!dt dt.trace_id={},dt.span_id={}] handle incoming message'.format(tinfo.trace_id,tinfo.span_id))See the documentation for more information:tracecontext_get_currentInformation on trace taggingW3C trace context in the SDK specification repositoryUsing the OneAgent SDK for Python with forked child processes (only available on Linux)Some applications, especially web servers, use a concurrency model that is based on forked child processes.
Typically a master process is started which is responsible only for creating and managing child processes by means of forking.
The child processes do the real work, for example handling web requests.The recommended way to use the Python SDK in such a scenario is as follows: You initialize the SDK in the master process setting
theforkableargument toTrue.oneagent.initialize(sdk_options,forkable=True)This way you will not be able to use the SDK in the master process (attempts to do so will be ignored, if applicable with
an error code), but all forked child processes will share the same agent. This has a lower overhead, for example the
startup of worker processes is not slowed down, and the per-worker memory overhead is reduced.For more information on forked child processes, take a look at those resources:Documentation on forking for the Dynatrace OneAgent SDK for C/C++Forking sample applicationTroubleshootingTo debug your OneAgent SDK for Python installation, execute the following Python code:importloggingimporttimeimportoneagentlog_handler=logging.StreamHandler()log_formatter=logging.Formatter('%(asctime)s.%(msecs)03dUTC [%(thread)08x]''%(levelname)-7s[%(name)-6s]%(message)s','%Y-%m-%d%H:%M:%S')log_formatter.converter=time.gmtimelog_handler.setFormatter(log_formatter)oneagent.logger.addHandler(log_handler)oneagent.logger.setLevel(1)init_result=oneagent.initialize(['loglevelsdk=finest','loglevel=finest'])print('InitResult='+repr(init_result))If you get output containingInitResult=InitResult(status=0, error=None), your installation should be fine. Otherwise, the output is helpful in
determining the issue. Theextended SKD statemight also help to diagnose your problem.Known gotchas:ImportErrororModuleNotFoundErrorin line 1 that says that there is no module namedoneagent.Make sure that thepip installor equivalent succeeded (seehere). Also make sure you use thepipcorresponding to yourpython(if in doubt, usepython -m pipinstead ofpipfor installing).Output ending in a message likeInitResult=InitResult(status=-2, error=SDKError(-1342308345, 'Failed loading SDK stub from .../site-packages/oneagent/_impl/native/libonesdk_shared.so: "/.../libonesdk_shared.so: cannot open shared object file: No such file or directory". Check your installation of the oneagent-sdk Python package, e.g., try runningpip install --verbose --force-reinstall oneagent-sdk.')).Follow the advice of the message and runpython -m pip install --verbose --force-reinstall oneagent-sdk(or the equivalent pip invocation with the--verboseand--force-reinstallflags).
It is likely that you will now see another message like******************************************************************************
  *** You are trying to build the Python SDK from source.                    ***
  *** This could mean that you are using an outdated version of pip (older   ***
  *** than 8.1.0) or you are attempting to install the SDK on an             ***
  *** unsupported platform. Please check the requirements at                 ***
  *** https://github.com/Dynatrace/OneAgent-SDK-for-Python#requirements      ***
  ******************************************************************************Make sure you are using pip to install a prebuilt package wheel for your system from PyPI, as described inUsing the OneAgent SDK for
Python in your application. Also make sure you are using an up-to date version ofpip,setuptoolsandwheel. You can
try upgrading them withpython -m pip install --upgrade pip setuptools wheel(make sure to use the samepythonthat you use to install
theoneagent-sdkpackage). ATTENTION: If you use the system-provided pip (e.g. installed viaapt-geton Ubuntu) you should instead use
apipinside avirtualenv(the same as your project), as upgrading system-provided packages viapipmay cause issues.If this does not resolve the issue, make sure you are using a supported platform, as listed inRequirements. If youareusing a supported system, you can try downloading theOneAgent SDK for C/C++in the
version corresponding to your OneAgent SDK for Python as listed inthe table in Requirements. Then set theDT_PYSDK_CSDK_PATHenvironment variable to the.so/.dllfile corresponding to your platform in thelibsubdirectory of the C SDK
and retry the installation (e.g. in a bash shell, useexport DT_PYSDK_CSDK_PATH=path/to/onesdk_shared.so). If there is no corresponding
directory, your platform is not supported. Otherwise, regardless if it works with that method or not, please report an issue as described
inLet us help you.Extended SDK StateFor debugging and/or diagnosing purposes you can also use the extended SDK state information.# The agent state is one of the integers in oneagent.sdk.AgentState.print('Agent state:',oneagent.get_sdk().agent_state)# The instance attribute 'agent_found' indicates whether an agent could be found or not.print('Agent found:',oneagent.get_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:',oneagent.get_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:',oneagent.get_sdk().agent_version_string)Shutdown crashesIf your are experiencing crashes when your application exits, make
sure you uninitialized the SDK properly by calling itsshutdownfunction.Repository contentsIf you are viewing theGitHub repository, you will see:LICENSE: License under which the whole SDK and sample applications are
published.src/: Actual source code of the Python OneAgent SDK.docs/: Source files for the (Sphinx-based) HTML
documentation. For the actual, readable documentation, seehere.tests/,test-util-src/: Contains tests and test support files that are
useful (only) for developers wanting to contribute to the SDK itself.setup.py,setup.cfg,MANIFEST.in,project.toml: Development files
required for creating e.g. the PyPI package for the Python OneAgent SDK.tox.ini,pylintrc: Supporting files for developing the SDK itself. Seehttps://tox.readthedocs.io/en/latest/andhttps://www.pylint.org/.Help & SupportSupport policyThe Dynatrace OneAgent SDK for Python has GA status. The features are fully supported by Dynatrace.For detailed support policy seeDynatrace OneAgent SDK help.Read the manualThe most recent version of the documentation for the Python SDK can be viewed athttps://dynatrace.github.io/OneAgent-SDK-for-Python/.A high level documentation/description of OneAgent SDK concepts is available athttps://github.com/Dynatrace/OneAgent-SDK/.Of course,this READMEalso contains lots of useful information.Let us help youMake sure your issue is not already solved in theavailable documentationbefore you ask for help. Especially thetroubleshooting section in this READMEmay prove helpful.Get HelpAsk a question in theproduct forums.Read theproduct documentationOpen aGitHub issueto:Report minor defects or typos.Ask any questions related to the community effort.SLAs don't apply for GitHub tickets.Customers can open a ticket on theDynatrace support portalto:Get support from the Dynatrace technical support engineering teamManage and resolve product related technical issuesSLAs apply according to the customer's support level.Release notes and announcementsFor additional updates, see alsoOneAgent release notesandEnd of support announcements.Announcements in November 2023⚠️Deprecation announcement for older SDK versions:Version 1.4 has been put on the path to deprecation and will no longer be supported starting June 1, 2024. Only version 1.5 of the SDK (or any newer version) will be supported from that date on.⚠️Deprecation announcement for using any SDK version with older Python versions:SDK support for Python 3.4.x, 3.5.x, 3.6.x and 3.7.x has been put on the path to deprecation and no version of the SDK will be supported on Python 3.4.x, 3.5.x and 3.6.x starting June 1, 2024.
Usage of the SDK on 3.7.x will remain supported until September 1, 2024.
All Python versions below 3.8.x are already declared End of Life by the Python.org project, and customers are encouraged to upgrade to a newer Python version that is also supported by Python.org.Version 1.5.1Changes:Fixes support of Python 3.12 and newerVersion 1.5.0Changes:Adds limitedW3C trace contextsupport (for log enrichment).This versionno longer supports Python 2 (Python 2.7.x).This versionno longer supports Python 3.4.x.Announcements:⚠️Deprecation announcement for older SDK versions:Version 1.3 and all older versions have been put on the path to deprecation and will no longer be supported starting July 1, 2023. We strongly advise customers to upgrade to newest versions to avoid incompatibility and security risks. Customers need to upgrade to at least 1.4 but are encouraged to upgrade to the newest available version (1.5) if using Python >3.4 as there are no known incompatibilities or breaking changes other than the increased minimum Python version.⚠️Deprecation announcement for using any SDK version with older Python versions:Python 2.7.x has been put on the path to deprecation and no version of the SDK will be supported on this Python version starting July 1, 2023. Furthermore, we intend to release a similar deprecation announcement regarding versions 3.4-3.6 (which are no longer maintained by the Python project) soon (we plan that this will not become effective before 2023-07-01).Seehttps://github.com/Dynatrace/OneAgent-SDK-for-Python/releasesfor older releases.LicenseSee the LICENSE file for details. It should be included in your distribution.
Otherwise, see the most recent version onGitHub.Summary: This software is licensed under the terms of the Apache License Version
2.0 and comes bundled with thesix library by Benjamin
Peterson, which is licensed under the terms of the
MIT license.