ex_distributed_tracing_client.c

/*
 * This application creates a DT payload, writes it in a request file and
 * waits until a response files is created. The creation of a response
 * file indicates, that the request file was handled.
 *
 * The server handling the request is contained in
 * ex_distributed_tracing_server.c
 *
 */
 
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
 
#include "common.h"
#include "libnewrelic.h"
 
#define REQUEST_FILE "/tmp/request"
#define RESPONSE_FILE "/tmp/response"
 
int main(void) {
  example_init();
 
  /* Initialize the config */
  char* app_name = get_app_name();
  if (NULL == app_name) {
    return -1;
  }
 
  char* license_key = get_license_key();
  if (NULL == license_key) {
    return -1;
  }
 
  newrelic_app_config_t* config
      = newrelic_create_app_config(app_name, license_key);
 
  customize_config(&config);
 
  /* Change the transaction tracer threshold to ensure a trace is generated */
  config->transaction_tracer.threshold = NEWRELIC_THRESHOLD_IS_OVER_DURATION;
  config->transaction_tracer.duration_us = 1;
 
  /* Enable distributed tracing */
  config->distributed_tracing.enabled = true;
 
  /* Wait up to 10 seconds for the SDK to connect to the daemon */
  newrelic_app_t* app = newrelic_create_app(config, 10000);
  newrelic_destroy_app_config(&config);
 
  /* Start a web transaction */
  newrelic_txn_t* txn = newrelic_start_web_transaction(app, "ExampleDTClient");
 
  /* Start an external segment */
  newrelic_segment_t* segment = newrelic_start_external_segment(
      txn, &(newrelic_external_segment_params_t){.procedure = "GET",
                                                 .uri = RESPONSE_FILE});
 
  /* Remove any left over request files */
  unlink(REQUEST_FILE);
 
  /*
   * Write a request file, which consists of a DT payload.
   *
   * NOTE: As a convention when communicating by HTTP/HTTPS, applications
   *       which are instrumented with New Relic send and receive DT
   *       payloads via the `newrelic` request header.
   */
  FILE* request_file = fopen(REQUEST_FILE, "w");
 
  if (request_file) {
    printf("Sending a request.\n");
 
    char* payload
        = newrelic_create_distributed_trace_payload_httpsafe(txn, segment);
 
    if (payload) {
      fprintf(request_file, "%s", payload);
      free(payload);
    }
 
    fclose(request_file);
 
    /* Wait for a response file to appear */
    printf("Waiting for response ... ");
    while (true) {
      FILE* response_file = fopen(RESPONSE_FILE, "r");
 
      if (response_file) {
        printf("received.\n\n");
        fclose(response_file);
        unlink(RESPONSE_FILE);
        break;
      }
 
      sleep(1);
    }
  } else {
    newrelic_notice_error(txn, 50, "Cannot send request",
                          "Error.class.request");
    printf("Error, cannot send request.\n");
  }
 
  /* End the external segment */
  newrelic_end_segment(txn, &segment);
 
  /* End web transaction */
  newrelic_end_transaction(&txn);
 
  newrelic_destroy_app(&app);
 
  return 0;
}