Dynatrace OpenKit API methods

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

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

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

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

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

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

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

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

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

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

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

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

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

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

std::shared_ptr<openkit::IAction> parentAction = action->leave(); // returns the appropriate RootAction
std::shared_ptr<openkit::IAction> parent = parentAction->leave(); // will always return nullptr

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

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

// first report an int value
string keyIntType = "intType";
int valueInt = 42;
action.ReportValue(keyIntType, valueInt);

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

string errorName = "Unknown Error";
int errorCode = 42;
string reason = "Not sure what's going on here";

action.ReportError(errorName, errorCode, reason);

const char* errorName = "Unknown Error";
int32_t errorCode = 42;
const char* reason = "Not sure what's going on here";

action->reportError(errorName, errorCode, reason);

const char* errorName = "Unknown Error";
int32_t errorCode = 42;
const char* reason = "Not sure what's going on here";

// report error on child action
reportErrorOnAction(action, errorName, errorCode, reason);
// report error on root action
reportErrorOnRootAction(rootAction, errorName, errorCode, reason);

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

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

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;

openKit.Shutdown();

openKit->shutdown();

shutdownOpenKit(openKit);