Dynatrace OpenKit API methods

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

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

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

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

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();

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);

const applicationID: string = 'application-id';
const deviceID: number = Util.getDeviceID();
const endpointURL: string = 'https://tenantid.beaconurl.com/mbeacon';

const openkit = new OpenKitBuilder(endpointURL, applicationID, deviceID).build();

class MyCustomTrustManager implements SSLTrustManager {
    // implement interface methods
}

SSLTrustManager trustManager = new MyCustomTrustManager()

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

class MyCustomTrustManager : ISSLTrustManager
{
    // implement interface methods
}

ISSLTrustManager trustManager = new MyCustomTrustManager()

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

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();

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);

class MyCustomTrustCommunicationChannel implements CommunicationChannel {
    // implement interface methods
}

const trustCommunicationChannel = new MyCustomTrustCommunicationChannel();

const openkit = new OpenKitBuilder(endpointURL, applicationID, deviceID)
    .withCommunicationChannel(trustCommunicationChannel)
    .build();

// 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);

// 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);

// 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);

// 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);

// wait until the OpenKit instance is fully initialized
openKit.waitForInit((initializedSuccessfully) => {});

// wait up to 10 seconds for OpenKit to complete initialization
const timeoutInMilliseconds = 10 * 1000;
openKit.waitForInit(() => {}, timeoutInMilliseconds);

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

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

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

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

const isInitialized = openKit.isInitialized();
if (isInitialized) {
    console.log('OpenKit is initialized');
} else {
    console.log('OpenKit is not yet initialized');
}

// 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();

// 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();

// 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();

// 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);

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

// create a session and let the IP be assigned on the server side
const sessionWithoutArgument = openKit.createSession();

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

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

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

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

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

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

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

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

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

session.end();

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);
    }
}

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);
    }
}

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);
    }
}

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);

const error = new Error('Some error');

// and now report the application crash via the session
session.reportCrash(e.name, e.message, e.stack);

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);

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);

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);

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);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

const eventName = "eventName";
action.reportEvent(eventName);

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

// 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);

// 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);

// 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);

// 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);

// first report a numeric value
const keyNumberName = 'My reported numeric value';
const numericValue = 42;
action.reportValue(keyNumberName, numericValue);

// and also a string value
const keyStringName = 'My reported string value';
const stringValue = 'The quick brown fox jumps over the lazy dog';
action.reportValue(keyStringName, stringValue);

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

action.reportError(errorName, errorCode);

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

action.ReportError(errorName, errorCode);

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

action->reportError(errorName, errorCode);

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);

const errorName = 'Unknown error';
const errorCode = 42;

action.reportError(errorName, errorCode);

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 ...
}

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 ...
}

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
}

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
}

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);
}

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);
}

// 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.stop(200); // would use the HTTP response code normally.

// --------------------------------------------
// 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.stop(200);               // 200 was the response code

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.Stop(200);               // 200 was the response code
}

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->stop(200);               // 200 was the response code

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
stopWebRequest(webRequestTracer, 200);     // 200 was the response code

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

const url = 'http://www.my-backend.com/api/v3/users';

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

const headerName = webRequestTagHeader; // webRequestTagHeader can be imported
const headerValue = webRequestTracer.getTag();

webRequestTracer.start();

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

webRequestTracer.setBytesSent(12345);
webRequestTracer.setBytesReceived(67890);
webRequestTracer.stop(200); // stop the web request tracer, with the response code

import com.dynatrace.openkit.DataCollectionLevel;
import com.dynatrace.openkit.CrashReportingLevel;

OpenKit openKit = new DynatraceOpenKitBuilder(endpointURL, applicationID, deviceID)
// set a data collection level (user allowed you to capture performance and personal data)
        .withDataCollectionLevel(DataCollectionLevel.USER_BEHAVIOR)
// allow crash reporting (user allowed you to collect information on crashes)
        .withCrashReportingLevel(CrashReportingLevel.OPT_IN_CRASHES)
        .build();

using Dynatrace.OpenKit;

var openKit = new DynatraceOpenKitBuilder(endpointURL, applicationID, deviceID)
// set a data collection level (user allowed you to capture performance and personal data)
     .WithDataCollectionLevel(DataCollectionLevel.USER_BEHAVIOR)
// allow crash reporting (user allowed you to collect information on crashes)
     .WithCrashReportingLevel(CrashReportingLevel.OPT_IN_CRASHES)
     .Build();

#include "OpenKit/OpenKit.h"

auto openKit = openkit::DynatraceOpenKitBuilder builder(endpointURL.c_str(), applicationID.c_str(), deviceID);
// set a data collection level (user allowed you to capture performance and personal data)
builder.withDataCollectionLevel(openkit::DataCollectionLevel::USER_BEHAVIOR)
// allow crash reporting (user allowed you to collect information on crashes)
       .withCrashReportingLevel(openkit::CrashReportingLevel::OPT_IN_CRASHES)
       .build();

#include "OpenKit/OpenKit-c.h"

struct OpenKitConfigurationHandle* configurationHandle = createOpenKitConfiguration(endpointURL, applicationID, deviceID);
// set a data collection level (user allowed you to capture performance and personal data)
useDataCollectionLevelForConfiguration(configurationHandle, DATA_COLLECTION_LEVEL_USER_BEHAVIOR);
// allow crash reporting (user allowed you to collect information on crashes)
useCrashReportingLevelForConfiguration(configurationHandle, CRASH_REPORTING_LEVEL_OPT_IN_CRASHES);

struct OpenKitHandle* openKitHandle = createDynatraceOpenKit(configurationHandle);
destroyOpenKitConfiguration(configurationHandle);