Dynatrace OpenKit API methods

javacopydownload
String applicationID = "application-id";
long deviceID = Util.getDeviceID();
String endpointURL = "https://tenantid.beaconurl.com/mbeacon";

OpenKit openKit = new DynatraceOpenKitBuilder(endpointURL, applicationID, deviceID).build();

cscopydownload
string applicationID = "application-id";
long deviceID = Util.GetDeviceID();
string endpointURL = "https://tenantid.beaconurl.com/mbeacon";

IOpenKit openKit = new DynatraceOpenKitBuilder(endpointURL, applicationID, deviceID).Build();

cppcopydownload
const char* applicationID = "application-id";
int64_t deviceID = Util::GetDeviceID();
const char* endpointURL = "https://tenantid.beaconurl.com/mbeacon";

std::shared_pointer<openkit::IOpenKit> openKit =
    openkit::DynatraceOpenKitBuilder(endpointURL, applicationID, deviceID).build();

ccopydownload
const char* applicationID = "application-id";
int64_t deviceID = GetDeviceID();
const char* endpointURL = "https://tenantid.beaconurl.com/mbeacon";

struct OpenKitConfigurationHandle* configurationHandle = createOpenKitConfiguration(endpointURL, applicationID, deviceID);
struct OpenKitHandle* openKitHandle = createDynatraceOpenKit(configurationHandle);
destroyOpenKitConfiguration(configurationHandle);

javacopydownload
class MyCustomTrustManager implements SSLTrustManager {
    // implement interface methods
}

SSLTrustManager trustManager = new MyCustomTrustManager()

OpenKit openKit = new DynatraceOpenKitBuilder(endpointURL, applicationID, deviceID)
    .withTrustManager(trustManager)
    .build();

cscopydownload
class MyCustomTrustManager : ISSLTrustManager
{
    // implement interface methods
}

ISSLTrustManager trustManager = new MyCustomTrustManager()

OpenKit openKit = new DynatraceOpenKitBuilder(endpointURL, applicationID, deviceID)
    .WithTrustManager(trustManager)
    .Build();

cppcopydownload
class MyCustomTrustManager : public openkit::ISSLTrustManager
{
    // implement interface methods
};

std::shared_ptr<openkit::ISSLTrustManager> trustManager = std::make_shared<MyCustomTrustManager>()

OpenKit openKit = new DynatraceOpenKitBuilder(endpointURL, applicationID, deviceID)
    .withTrustManager(trustManager)
    .build();

ccopydownload
void applySslOptions(CURL* curl)
{
    // set CURL options accordingly
}

struct TrustManagerHandle* trustManager = createCustomTrustManager(&applySslOptions);

// create OpenKit configuration and assign custom trust manager
struct OpenKitConfigurationHandle* configurationHandle = createOpenKitConfiguration(endpointURL, applicationID, deviceID);
useTrustModeForConfiguration(configurationHandle, CUSTOM_TRUST, trustManager);

// create OpenKit instance
struct OpenKitHandle* openKitHandle = createDynatraceOpenKit(configurationHandle);

javacopydownload
// wait until the OpenKit instance is fully initialized
boolean success = openKit.waitForInitCompletion();

// wait up to 10 seconds for OpenKit to complete initialization
long timeoutInMilliseconds = 10 * 1000;
boolean success = openKit.waitForInitCompletion(timeoutInMilliseconds);

cscopydownload
// wait until the OpenKit instance is fully initialized
bool success = openKit.WaitForInitCompletion();

// wait up to 10 seconds for OpenKit to complete initialization
int timeoutInMilliseconds = 10 * 1000;
bool success = openKit.WaitForInitCompletion(timeoutInMilliseconds);

cppcopydownload
// wait until the OpenKit instance is fully initialized
bool success = openKit->waitForInitCompletion();

// wait up to 10 seconds for OpenKit to complete initialization
int64_t timeoutInMilliseconds = 10 * 1000;
bool success = openKit->waitForInitCompletion(timeoutInMilliseconds);

ccopydownload
// wait until the OpenKit instance is fully initialized
bool success = waitForInitCompletion(openKit);

// wait up to 10 seconds for OpenKit to complete initialization
int64_t timeoutInMilliseconds = 10 * 1000;
bool success = waitForInitCompletionWithTimeout(openKit, timeoutInMilliseconds);

javacopydownload
boolean isInitialized = openKit.isInitialized();
if (isInitialized) {
    System.out.println("OpenKit is initialized");
} else {
    System.out.println("OpenKit is not yet initialized");
}

cscopydownload
bool isInitialized = openKit.IsInitialized;
if (isInitialized)
{
    Console.WriteLine("OpenKit is initialized");
}
else
{
    Console.WriteLine("OpenKit is not yet initialized");
}

cppcopydownload
bool isInitialized = openKit->isInitialized();
if (isInitialized)
{
    std::cout << "OpenKit is initialized" << std::endl;
}
else
{
    std::cout << "OpenKit is not yet initialized" << std::endl;
}

ccopydownload
bool isInitialized = isInitialized(openKit);
if (isInitialized)
{
    printf("OpenKit is initialized\n");
}
else
{
    printf("OpenKit is not yet initialized\n");
}

javacopydownload
// create a session and pass an IP address
String clientIPAddress = "12.34.56.78";
Session sessionWithArgument = openKit.createSession(clientIPAddress);

// create a session and let the IP be assigned on the server side
// this overloaded method is available since OpenKit Java 1.4.0
Session sessionWithoutArgument = openKit.createSession();

cscopydownload
// create a session and pass an IP address
string clientIPAddress = "12.34.56.78";
ISession sessionWithArgument = openKit.CreateSession(clientIPAddress);

// create a session and let the IP be assigned on the server side
// this overloaded method is available since OpenKit .NET 1.4.0
ISession sessionWithoutArgument = openKit.CreateSession();

cscopydownload
// create a session and pass an IP address
const char* clientIPAddress = "12.34.56.78";
std::shared_ptr<openkit::ISession> sessionWithArgument = openKit->createSession(clientIPAddress);

// create a session and let the IP be assigned on the server side
// this overloaded method is available since OpenKit Native 1.1.0
std::shared_ptr<openkit::ISession> sessionWithoutArgument = openKit->createSession();

cscopydownload
// create a session and pass an IP address
const char* clientIPAddress = "12.34.56.78";
SessionHandle* sessionWithArgument = createSession(openKit, clientIPAddress);

// create a session and let the IP be assigned on the server side
// this function is available since OpenKit Native 1.1.0
SessionHandle* sessionWithoutArgument = createSessionWithAutoIpDetermination(openKit);

javacopydownload
session.identifyUser("jane.doe@example.com");

cscopydownload
session.IdentifyUser("jane.doe@example.com");

cppcopydownload
session->identifyUser("jane.doe@example.com");

ccopydownload
identifyUser(session, "jane.doe@example.com");

javacopydownload
session.end();
session = null; // not needed, just used to indicate that the session is no longer valid.

cscopydownload
session.End();
session = null; // not needed, just used to indicate that the session is no longer valid.

cppcopydownload
session->end();
session = nullptr; // not needed, just used to indicate that the session is no longer valid.

ccopydownload
endSession(session);
session = NULL; // good pratice, as the allocated memory is freed in endSession

javacopydownload
private static int div(int numerator, int denominator) {
    return numerator / denominator;
}

public static void divWithCrash() {
    int numerator = 5;
    int denominator = 0;
    try {
        System.out.println("Got: " + div(numerator, denominator));
    } catch (Exception e) {
        String errorName = e.getClass().getName();
        String reason = e.getMessage();
        String stackTrace = getStackTraceAsString(e); // get the stacktrace as string, similar as e.printStackTrace()
        // and now report the application crash via the session
        session.reportCrash(errorName, reason, stackTrace);
    }
}

cscopydownload
private static int Div(int numerator, int denominator)
{
    return numerator / denominator;
}

public static void DivWithCrash()
{
    int numerator = 5;
    int denominator = 0;
    try
    {
        Console.WriteLine("Got: " + Div(numerator, denominator));
    }
    catch (Exception e)
    {
        string errorName = e.GetType().ToString();
        string reason = e.Message;
        string stackTrace = e.StackTrace;
        // and now report the application crash via the session
        session.ReportCrash(errorName, reason, stackTrace);
    }
}

cppcopydownload
static int32_t div(int32_t numerator, int32_t denominator)
{
    if (denominator == 0)
    {
        throw std::logic_error("Division by zero");
    }

    return numerator / denominator;
}

static void divWithCrash()
{
    int32_t numerator = 5;
    int32_t denominator = 0;
    try
    {
        int32_t result = div(numerator, denominator);
        std::cout << "Got: " << result << std::endl;
    }
    catch (std::logic_error& e)
    {
        const char* errorName = "std::logic_error"; // if RTTI is enabled, typeid could be used
        const char* reason = e.what();
        const char* stackTrace = nullptr; // use a valid const char* if a stack trace can be generated
        // and now report the application crash via the session
        session->reportCrash(errorName, reason, stackTrace);
    }
}

ccopydownload
const char* errorName = "application crash";
const char* reason = "some reason indicator";
const char* stackTrace = NULL; // use a valid const char* if a stack trace can be generated

 // and now report the application crash via the session
reportCrash(session, errorName, reason, stackTrace);

javacopydownload
String rootActionName = "rootActionName";
String childActionName = "childActionName";
// create a custom action for a session
RootAction rootAction = session.enterAction(rootActionName);
// create a child action for the custom action
Action childAction = rootAction.enterAction(childActionName);

cscopydownload
string rootActionName = "rootActionName";
string childActionName = "childActionName";
// create a custom action for a session
IRootAction rootAction = session.EnterAction(rootActionName);
// create a child action for the custom action
IAction childAction = rootAction.EnterAction(childActionName);

cppcopydownload
const char* rootActionName = "rootActionName";
const char* childActionName = "childActionName";
// create a custom action for a session
std::shared_ptr<openkit::IRootAction> rootAction = session->enterAction(rootActionName);
// create a child action for the custom action
std::shared_ptr<openkit::IAction> childAction = rootAction->enterAction(childActionName);

ccopydownload
const char* rootActionName = "rootActionName";
const char* childActionName = "childActionName";
// create a custom action for a session
RootActionHandle* rootAction = enterRootAction(session, rootActionName);
// create a child action for the custom action
ActionHandle* childAction = enterAction(rootAction, childActionName);

javacopydownload
Action parentAction = action.leaveAction(); // returns the appropriate custom action
Action parent = parentAction.leaveAction(); // will always return null

cscopydownload
IAction parentAction = action.LeaveAction(); // returns the appropriate custom action
IAction parent = parentAction.LeaveAction(); // will always return null

cppcopydownload
std::shared_ptr<openkit::IRootAction> parentAction = action->leaveAction(); // returns the appropriate custom action
parentAction->leaveAction(); // return type is void

ccopydownload
leaveAction(action); // return type is void
leaveRootAction(rootAction); // return type is void

javacopydownload
Action parentAction = action.cancelAction(); // returns the appropriate custom action
Action parent = parentAction.cancelAction(); // will always return null

cscopydownload
IAction parentAction = action.CancelAction(); // returns the appropriate custom action
IAction parent = parentAction.CancelAction(); // will always return null

cppcopydownload
std::shared_ptr<openkit::IRootAction> parentAction = action->cancelAction(); // returns the appropriate custom action
parentAction->cancelAction(); // return type is void

ccopydownload
cancelAction(action); // return type is void
cancelRootAction(rootAction); // return type is void

javacopydownload
String eventName = "eventName";
action.reportEvent(eventName);

// also report on the RootAction
rootAction.reportEvent(eventName);

cscopydownload
string eventName = "eventName";
action.ReportEvent(eventName);

// also report on the RootAction
rootAction.ReportEvent(eventName);

cppcopydownload
const char* eventName = "eventName";
action->reportEvent(eventName);

// also report on the RootAction
rootAction->reportEvent(eventName);

ccopydownload
const char* eventName = "eventName";
reportEventOnAction(action, eventName);

// also report on the RootAction
reportEventOnRootAction(rootAction, eventName);

javacopydownload
// first report a 32-bit int value
String keyIntType = "intType";
int valueInt = 42;
action.reportValue(keyIntType, valueInt);

// then let's report a 64-bit long value
String keyLongType = "longType";
long valueLong = Long.MIN_VALUE;
action.reportValue(keyLongType, valueLong);

// then let's report a double value
String keyDoubleType = "doubleType";
double valueDouble = 3.141592653589793;
action.reportValue(keyDoubleType, valueDouble);

// and also a string value
String keyStringType = "stringType";
String valueString = "The quick brown fox jumps over the lazy dog";
action.reportValue(keyStringType, valueString);

cscopydownload
// first report a 32-bit int value
string keyIntType = "intType";
int valueInt = 42;
action.ReportValue(keyIntType, valueInt);

// then let's report a 64-bit long value
string keyLongType = "longType";
long valueLong = long.MinValue;
action.ReportValue(keyLongType, valueLong);

// then let's report a double value
string keyDoubleType = "doubleType";
double valueDouble = 3.141592653589793;
action.ReportValue(keyDoubleType, valueDouble);

// and also a string value
string keyStringType = "stringType";
string valueString = "The quick brown fox jumps over the lazy dog";
action.ReportValue(keyStringType, valueString);

cppcopydownload
// first report a 32-bit integer value
const char* keyIntType = "intType";
int32_t valueInt = 42;
action->reportValue(keyIntType, valueInt);

// then let's report a 64-bit integer value
const char* keyLongType = "longType";
int64_t valueLong = LLONG_MIN;
action->reportValue(keyLongType, valueLong);

// then let's report a double value
const char* keyDoubleType = "doubleType";
double valueDouble = 3.141592653589793;
action->reportValue(keyDoubleType, valueDouble);

// and also a string value
const char* keyStringType = "stringType";
const char* valueString = "The quick brown fox jumps over the lazy dog";
action->reportValue(keyStringType, valueString);

ccopydownload
// first report a 32-bit integer value
const char* keyIntType = "intType";
int32_t valueInt = 42;
reportIntValueOnAction(action, keyIntType, valueInt);

// then let's report a 64-bit integer value
const char* keyLongType = "longType";
int64_t valueLong = LLONG_MIN;
reportInt64ValueOnAction(keyLongType, valueLong);

// then let's report a double value
const char* keyDoubleType = "doubleType";
double valueDouble = 3.141592653589793;
reportDoubleValueOnAction(action, keyDoubleType, valueDouble);

// and also a string value
const char* keyStringType = "stringType";
const char* valueString = "The quick brown fox jumps over the lazy dog";
reportStringValueOnAction(action, keyStringType, valueString);

javacopydownload
String errorName = "Unknown Error";
int errorCode = 42;

action.reportError(errorName, errorCode);

cscopydownload
string errorName = "Unknown Error";
int errorCode = 42;

action.ReportError(errorName, errorCode);

cppcopydownload
const char* errorName = "Unknown Error";
int32_t errorCode = 42;

action->reportError(errorName, errorCode);

ccopydownload
const char* errorName = "Unknown Error";
int32_t errorCode = 42;

// report error on a child action
reportErrorOnAction(action, errorName, errorCode);
// report error on a custom action
reportErrorOnRootAction(rootAction, errorName, errorCode);

javacopydownload
public void restrictedMethod() {
    if (!isUserAuthorized()) {
        // user is not authorized - report this as an error
        String errorName = "Authorization error";
        String causeName = "User not authorized";
        String causeDescription = "The current user is not authorized to call restrictedMethod.";
        String stackTrace = null; // no stack trace is reported

        action.reportError(errorName, causeName, causeDescription, stackTrace);

        return;
    }

    // ... further processing ...
}

cscopydownload
public void RestrictedMethod()
{
    if (!IsUserAuthorized())
    {
        // user is not authorized - report this as an error
        string errorName = "Authorization error";
        string causeName = "User not authorized";
        string causeDescription = "The current user is not authorized to call restrictedMethod.";
        string stackTrace = null; // no stack trace is reported

        action.ReportError(errorName, causeName, causeDescription, stackTrace);

        return;
    }

    // ... further processing ...
}

cppcopydownload
void RestrictedClass::restrictedMethod()
{
    if (!isUserAuthorized())
    {
        const char* errorName = "Authorization error";
        const char* causeName = "User not authorized";
        const char* causeDescription = "The current user is not authorized to call restrictedMethod.";
        const char* causeStackTrace = nullptr; // no stack trace is reported

        // report the error on IAction
        action->reportError(errorName, causeName, causeDescription, causeStackTrace);
        // report the error on IRootAction
        rootAction->reportError(errorName, causeName, causeDescription, causeStackTrace);

        return;
    }

    // ... further processing
}

ccopydownload
void restrictedFunction()
{
    if (!isUserAuthorized())
    {
        const char* errorName = "Authorization error";
        const char* causeName = "User not authorized";
        const char* causeDescription = "The current user is not authorized to call restrictedFunction.";
        const char* causeStackTrace = NULL; // no stack trace is reported

        // report error on child action
        reportErrorCauseOnAction(action, errorName, causeName, causeDescription, causeStackTrace);
        // report error on custom action
        reportErrorCauseOnRootAction(rootAction, errorName, causeName, causeDescription, causeStackTrace);

        return;
    }

    // ... further processing
}

javacopydownload
try {
    // call a method that is throwing an exception
    callMethodThrowingException();
} catch(Exception caughtException) {
    // report the caught exception as error via OpenKit
    String errorName = "Unknown Error";
    action.reportError(errorName, caughtException);
}

cscopydownload
try
{
    // call a method that is throwing an exception
    CallMethodThrowingException();
}
catch(Exception caughtException)
{
    // report the caught exception as error via OpenKit
    string errorName = "Unknown Error";
    action.ReportError(errorName, caughtException);
}

javacopydownload
// create URL and open URLConnection
URL url = new URL("http://www.my-backend.com/api/v3/users");
URLConnection urlConnection = url.openConnection();

// create the WebRequestTracer
WebRequestTracer webRequestTracer = action.traceWebRequest(urlConnection);
webRequestTracer.start();

// consume data
BufferedReader in = new BufferedReader(new InputStreamReader(uc.getInputStream()));
String inputLine;
while ((inputLine = in.readLine()) != null) {
    // TODO - do something useful with response
}
in.close();

// stop web request tracing when done
webRequestTracer.setResponseCode(200); // would use the HTTP response code normally.
webRequestTracer.stop();

// --------------------------------------------
// alternative solution not using URLConnection
// --------------------------------------------

String url = "http://www.my-backend.com/api/v3/users";

// create the WebRequestTracer
WebRequestTracer webRequestTracer = action.traceWebRequest(url);

// this is the HTTP header name & value which needs to be added to the HTTP request.
String headerName = OpenKitConstants.WEBREQUEST_TAG_HEADER;
String headerValue = webRequestTracer.getTag();

webRequestTracer.start();

// perform the request here & do not forget to add the HTTP header

webRequestTracer.setBytesSent(12345);     // 12345 bytes sent
webRequestTracer.setBytesReceived(67890); // 67890 bytes received
webRequestTracer.setResponseCode(200);    // 200 was the response code
webRequestTracer.stop();

// Note: Since OpenKit .NET version 2.0.0
// webRequestTracer.Stop(200);
// can be used to set the response code and stop tracing.

cscopydownload
string url = "http://www.my-backend.com/api/v3/users";

// create the WebRequestTracer
IWebRequestTracer webRequestTracer = action.TraceWebRequest(url);

// this is the HTTP header name & value which needs to be added to the HTTP request.
string headerName = OpenKitConstants.WEBREQUEST_TAG_HEADER;
string headerValue = webRequestTracer.Tag;

// perform the request here & do not forget to add the HTTP header
using (HttpClient httpClient = new HttpClient()) {

    // start timing
    webRequestTracer.Start();

    // set the tag
    httpClient.DefaultRequestHeaders.Add(headerName, headerValue);

    // ... perform the request and process the response ...

    // set metadata
    webRequestTracer.SetBytesSent(12345);     // 12345 bytes sent
    webRequestTracer.SetBytesReceived(67890); // 67890 bytes received
    webRequestTracer.SetResponseCode(200);    // 200 was the response code

    // stop timing
    webRequestTracer.Stop();

    // Note: Since OpenKit .NET version 2.0.0
    // webRequestTracer.Stop(200);
    // can be used to set the response code and stop tracing.
}

cppcopydownload
const char* url = "http://www.my-backend.com/api/v3/users";

// create the WebRequestTracer
std::shared_ptr<openkit::IWebRequestTracer> webRequestTracer = action->traceWebRequest(url);

// this is the HTTP header name & value which needs to be added to the HTTP request.
const char* headerName = openkit::WEBREQUEST_TAG_HEADER;
const char* headerValue = webRequestTracer->getTag();

// start timing
webRequestTracer->start();

// set the tag on httpRequest
// Note: how to set this, depends on the HTTP client library in use
httpRequest.addHeader(headerName, headerValue);

// ... perform the request and process the response ...

// set metadata
webRequestTracer->setBytesSent(12345);     // 12345 bytes sent
webRequestTracer->setBytesReceived(67890); // 67890 bytes received
webRequestTracer->setResponseCode(200);    // 200 was the response code

// stop timing
webRequestTracer->stop();

ccopydownload
const char* url = "http://www.my-backend.com/api/v3/users";

// create the WebRequestTracer on child action
WebRequestTracerHandle* webRequestTracer = traceWebRequestOnRootAction(rootAction, url);
// Alterantively web requests can be created on a child action like below
// WebRequestTracerHandle* webRequestTracer = traceWebRequestOnAction(action, url);

// this is the HTTP header name & value which needs to be added to the HTTP request.
const char* headerName = WEBREQUEST_TAG_HEADER;
const char* headerValue = getTag(webRequestTracer);

// start timing
startWebRequest(webRequestTracer)

// set the tag on httpRequest
// Note: how to set this, depends on the HTTP client library in use
addCustomHeaderToWebRequest(httpRequest, headerName, headerValue);

// ... perform the request and process the response ...

// set metadata
setBytesSent(webRequestTracer, 12345);     // 12345 bytes sent
setBytesReceived(webRequestTracer, 67890); // 67890 bytes received
setResponseCode(webRequestTracer, 200);    // 200 was the response code

// stop timing
stopWebRequest(webRequestTracer);
// After calling stopWebRequest the allocated memory is freed and therefore
// webRequestTracer is no longer valid.
webRequestTracer = NULL;

javacopydownload
openKit.shutdown();

cscopydownload
openKit.Shutdown();

cppcopydownload
openKit->shutdown();

ccopydownload
shutdownOpenKit(openKit);