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

Map <String, JSONValue> attributes = new HashMap<String, JSONValue>();
attributes.put("event.name", JSONStringValue.fromString("Confirmed Booking"));
attributes.put("screen", JSONStringValue.fromString("booking-confirmation"));
attributes.put("product", JSONStringValue.fromString("Danube Anna Hotel"));
attributes.put("amount", JSONNumberValue.fromDouble(358.35));
attributes.put("currency", JSONStringValue.fromString("USD"));
attributes.put("reviewScore", JSONNumberValue.fromDouble(4.8));
attributes.put("arrivalDate", JSONStringValue.fromString("2022-11-05"));
attributes.put("departureDate", JSONStringValue.fromString("2022-11-15"));
attributes.put("journeyDuration", JSONNumberValue.fromLong(10));
attributes.put("adultTravelers", JSONNumberValue.fromLong(2));
attributes.put("childrenTravelers", JSONNumberValue.fromLong(0));

session.sendBizEvent('com.easytravel.funnel.booking-finished', attributes);

Dictionary<string, JsonValue> attributes = new Dictionary<string, JsonValue>();
attributes.Add("event.name", JsonStringValue.FromString("Confirmed Booking"));
attributes.Add("screen", JsonStringValue.FromString("booking-confirmation"));
attributes.Add("product", JsonStringValue.FromString("Danube Anna Hotel"));
attributes.Add("amount", JsonNumberValue.FromDouble(358.35));
attributes.Add("currency", JsonStringValue.FromString("USD"));
attributes.Add("reviewScore", JsonNumberValue.FromDouble(4.8));
attributes.Add("arrivalDate", JsonStringValue.FromString("2022-11-05"));
attributes.Add("departureDate", JsonStringValue.FromString("2022-11-15"));
attributes.Add("journeyDuration", JsonNumberValue.FromLong(10));
attributes.Add("adultTravelers", JsonNumberValue.FromLong(2));
attributes.Add("childrenTravelers", JsonNumberValue.FromLong(0));

session.SendBizEvent("com.easytravel.funnel.booking-finished", attributes);

auto attributes = std::make_shared<openkit::json::JsonObjectValue::JsonObjectMap>(
    std::initializer_list<openkit::json::JsonObjectValue::JsonObjectMap::value_type>{
        { "event.name", openkit::json::JsonStringValue::fromString("Confirmed Booking") },
        { "screen", openkit::json::JsonStringValue::fromString("booking-confirmation") },
        { "product", openkit::json::JsonStringValue::fromString("Danube Anna Hotel") },
        { "amount", openkit::json::JsonNumberValue::fromDouble(358.35) },
        { "currency", openkit::json::JsonStringValue::fromString("USD") },
        { "reviewScore", openkit::json::JsonNumberValue::fromDouble(4.8) },
        { "arrivalDate", openkit::json::JsonStringValue::fromString("2022-11-05") },
        { "departureDate", openkit::json::JsonStringValue::fromString("2022-11-15") },
        { "journeyDuration", openkit::json::JsonNumberValue::fromLong(10) },
        { "adultTravelers", openkit::json::JsonNumberValue::fromLong(2) },
        { "childrenTravelers", openkit::json::JsonNumberValue::fromLong(0) }
    }
);

size_t attributesSize = 11;
OpenKitPair* attributes = malloc(sizeof(OpenKitPair) * attributesSize);

if (attributes == NULL)
{
    fprintf(stderr, "malloc of attributes for sendBizEvent is not working.");
    exit(-1);
}

attributes[0] = (OpenKitPair) { "event.name", "\"Confirmed Booking\"" };
attributes[1] = (OpenKitPair) { "screen", "\"booking-confirmation\"" };
attributes[2] = (OpenKitPair) { "product", "\"Danube Anna Hotel\"" };
attributes[3] = (OpenKitPair) { "amount", "358.35" };
attributes[4] = (OpenKitPair) { "currency", "\"USD\"" };
attributes[5] = (OpenKitPair) { "reviewScore", "4.8" };
attributes[6] = (OpenKitPair) { "arrivalDate", "\"2022-11-05\"" };
attributes[7] = (OpenKitPair) { "departureDate", "\"2022-11-15\"" };
attributes[8] = (OpenKitPair) { "journeyDuration", "10" };
attributes[9] = (OpenKitPair) { "adultTravelers", "2" };
attributes[10] = (OpenKitPair) { "childrenTravelers", "0" };

sendBizEvent(sessionHandle, "Event", attributes, attributesSize);
free(attributes);

session.sendBizEvent('com.easytravel.funnel.booking-finished', {
    'event.name': 'Confirmed Booking',
    screen: 'booking-confirmation',
    product: 'Danube Anna Hotel',
    amount: 358.35,
    currency: 'USD',
    reviewScore: 4.8,
    arrivalDate: '2022-11-05',
    departureDate: '2022-11-15',
    journeyDuration: 10,
    adultTravelers: 2,
    childrenTravelers: 0,
});

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