libnewrelic.h

Go to the documentation of this file.

 
#ifndef LIBNEWRELIC_H
#define LIBNEWRELIC_H
 
#include <stdbool.h>
#include <stdint.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define NEWRELIC_DATASTORE_FIREBIRD "Firebird"
#define NEWRELIC_DATASTORE_INFORMIX "Informix"
#define NEWRELIC_DATASTORE_MSSQL "MSSQL"
#define NEWRELIC_DATASTORE_MYSQL "MySQL"
#define NEWRELIC_DATASTORE_ORACLE "Oracle"
#define NEWRELIC_DATASTORE_POSTGRES "Postgres"
#define NEWRELIC_DATASTORE_SQLITE "SQLite"
#define NEWRELIC_DATASTORE_SYBASE "Sybase"
 
 
#define NEWRELIC_DATASTORE_MEMCACHE "Memcached"
#define NEWRELIC_DATASTORE_MONGODB "MongoDB"
#define NEWRELIC_DATASTORE_ODBC "ODBC"
#define NEWRELIC_DATASTORE_REDIS "Redis"
#define NEWRELIC_DATASTORE_OTHER "Other"
 
 
#define NEWRELIC_TRANSPORT_TYPE_UNKNOWN "Unknown"
#define NEWRELIC_TRANSPORT_TYPE_HTTP "HTTP"
#define NEWRELIC_TRANSPORT_TYPE_HTTPS "HTTPS"
#define NEWRELIC_TRANSPORT_TYPE_KAFKA "Kafka"
#define NEWRELIC_TRANSPORT_TYPE_JMS "JMS"
#define NEWRELIC_TRANSPORT_TYPE_IRONMQ "IronMQ"
#define NEWRELIC_TRANSPORT_TYPE_AMQP "AMQP"
#define NEWRELIC_TRANSPORT_TYPE_QUEUE "Queue"
#define NEWRELIC_TRANSPORT_TYPE_OTHER "Other"
 
 
typedef struct _nr_app_and_info_t newrelic_app_t;
 
typedef struct _newrelic_txn_t newrelic_txn_t;
 
typedef uint64_t newrelic_time_us_t;
 
typedef enum _newrelic_loglevel_t {
 
  NEWRELIC_LOG_ERROR,
 
  NEWRELIC_LOG_WARNING,
 
  NEWRELIC_LOG_INFO,
 
  NEWRELIC_LOG_DEBUG,
} newrelic_loglevel_t;
 
typedef enum _newrelic_tt_recordsql_t {
  NEWRELIC_SQL_OFF,
 
  NEWRELIC_SQL_RAW,
 
  NEWRELIC_SQL_OBFUSCATED
} newrelic_tt_recordsql_t;
 
typedef enum _newrelic_transaction_tracer_threshold_t {
  NEWRELIC_THRESHOLD_IS_APDEX_FAILING,
 
  NEWRELIC_THRESHOLD_IS_OVER_DURATION,
} newrelic_transaction_tracer_threshold_t;
 
typedef struct _newrelic_transaction_tracer_config_t {
  bool enabled;
 
  newrelic_transaction_tracer_threshold_t threshold;
 
  newrelic_time_us_t duration_us;
 
  newrelic_time_us_t stack_trace_threshold_us;
 
  struct {
    bool enabled;
 
    newrelic_tt_recordsql_t record_sql;
 
    newrelic_time_us_t threshold_us;
  } datastore_reporting;
 
} newrelic_transaction_tracer_config_t;
 
typedef struct _newrelic_datastore_segment_config_t {
  bool instance_reporting;
 
  bool database_name_reporting;
 
} newrelic_datastore_segment_config_t;
 
typedef struct _newrelic_distributed_tracing_config_t {
  bool enabled;
} newrelic_distributed_tracing_config_t;
 
typedef struct _newrelic_span_event_config_t {
  bool enabled;
} newrelic_span_event_config_t;
 
typedef struct _newrelic_app_config_t {
  char app_name[255];
 
  char license_key[255];
 
  char redirect_collector[100];
 
  char log_filename[512];
 
  newrelic_loglevel_t log_level;
 
  newrelic_transaction_tracer_config_t transaction_tracer;
 
  newrelic_datastore_segment_config_t datastore_tracer;
 
  newrelic_distributed_tracing_config_t distributed_tracing;
 
  newrelic_span_event_config_t span_events;
 
} newrelic_app_config_t;
 
typedef struct _newrelic_datastore_segment_params_t {
  char* product;
 
  char* collection;
 
  char* operation;
 
  char* host;
 
  char* port_path_or_id;
 
  char* database_name;
 
  char* query;
} newrelic_datastore_segment_params_t;
 
typedef struct _newrelic_external_segment_params_t {
  char* uri;
 
  char* procedure;
 
  char* library;
} newrelic_external_segment_params_t;
 
bool newrelic_configure_log(const char* filename, newrelic_loglevel_t level);
 
bool newrelic_init(const char* daemon_socket, int time_limit_ms);
 
newrelic_app_config_t* newrelic_create_app_config(const char* app_name,
                                                  const char* license_key);
 
bool newrelic_destroy_app_config(newrelic_app_config_t** config);
 
newrelic_app_t* newrelic_create_app(const newrelic_app_config_t* config,
                                    unsigned short timeout_ms);
 
bool newrelic_destroy_app(newrelic_app_t** app);
 
newrelic_txn_t* newrelic_start_web_transaction(newrelic_app_t* app,
                                               const char* name);
 
newrelic_txn_t* newrelic_start_non_web_transaction(newrelic_app_t* app,
                                                   const char* name);
 
bool newrelic_set_transaction_timing(newrelic_txn_t* transaction,
                                     newrelic_time_us_t start_time,
                                     newrelic_time_us_t duration);
 
bool newrelic_end_transaction(newrelic_txn_t** transaction_ptr);
 
bool newrelic_add_attribute_int(newrelic_txn_t* transaction,
                                const char* key,
                                const int value);
 
bool newrelic_add_attribute_long(newrelic_txn_t* transaction,
                                 const char* key,
                                 const long value);
 
bool newrelic_add_attribute_double(newrelic_txn_t* transaction,
                                   const char* key,
                                   const double value);
 
bool newrelic_add_attribute_string(newrelic_txn_t* transaction,
                                   const char* key,
                                   const char* value);
 
void newrelic_notice_error(newrelic_txn_t* transaction,
                           int priority,
                           const char* errmsg,
                           const char* errclass);
 
typedef struct _newrelic_segment_t newrelic_segment_t;
 
typedef struct _newrelic_custom_event_t newrelic_custom_event_t;
 
newrelic_segment_t* newrelic_start_segment(newrelic_txn_t* transaction,
                                           const char* name,
                                           const char* category);
 
newrelic_segment_t* newrelic_start_datastore_segment(
    newrelic_txn_t* transaction,
    const newrelic_datastore_segment_params_t* params);
 
newrelic_segment_t* newrelic_start_external_segment(
    newrelic_txn_t* transaction,
    const newrelic_external_segment_params_t* params);
 
bool newrelic_set_segment_parent(newrelic_segment_t* segment,
                                 newrelic_segment_t* parent);
 
bool newrelic_set_segment_parent_root(newrelic_segment_t* segment);
 
bool newrelic_set_segment_timing(newrelic_segment_t* segment,
                                 newrelic_time_us_t start_time,
                                 newrelic_time_us_t duration);
 
bool newrelic_end_segment(newrelic_txn_t* transaction,
                          newrelic_segment_t** segment_ptr);
 
newrelic_custom_event_t* newrelic_create_custom_event(const char* event_type);
 
void newrelic_discard_custom_event(newrelic_custom_event_t** event);
 
void newrelic_record_custom_event(newrelic_txn_t* transaction,
                                  newrelic_custom_event_t** event);
 
bool newrelic_custom_event_add_attribute_int(newrelic_custom_event_t* event,
                                             const char* key,
                                             int value);
 
bool newrelic_custom_event_add_attribute_long(newrelic_custom_event_t* event,
                                              const char* key,
                                              long value);
 
bool newrelic_custom_event_add_attribute_double(newrelic_custom_event_t* event,
                                                const char* key,
                                                double value);
 
bool newrelic_custom_event_add_attribute_string(newrelic_custom_event_t* event,
                                                const char* key,
                                                const char* value);
 
const char* newrelic_version(void);
 
bool newrelic_record_custom_metric(newrelic_txn_t* transaction,
                                   const char* metric_name,
                                   double milliseconds);
 
bool newrelic_ignore_transaction(newrelic_txn_t* transaction);
 
char* newrelic_create_distributed_trace_payload(newrelic_txn_t* transaction,
                                                newrelic_segment_t* segment);
 
bool newrelic_accept_distributed_trace_payload(newrelic_txn_t* transaction,
                                               const char* payload,
                                               const char* transport_type);
 
char* newrelic_create_distributed_trace_payload_httpsafe(
    newrelic_txn_t* transaction,
    newrelic_segment_t* segment);
 
bool newrelic_accept_distributed_trace_payload_httpsafe(
    newrelic_txn_t* transaction,
    const char* payload,
    const char* transport_type);
 
bool newrelic_set_transaction_name(newrelic_txn_t* transaction,
                                   const char* transaction_name);
 
#ifdef __cplusplus
}
#endif
 
#endif /* LIBNEWRELIC_H */