lib_guzzle_common.c

/*
 * Copyright 2020 New Relic Corporation. All rights reserved.
 * SPDX-License-Identifier: Apache-2.0
 */

#include "php_agent.h"
#include "php_call.h"
#include "php_user_instrument.h"
#include "php_hash.h"
#include "php_wrapper.h"
#include "lib_guzzle_common.h"
#include "lib_guzzle4.h"
#include "lib_guzzle6.h"
#include "nr_header.h"
#include "util_logging.h"
#include "util_memory.h"
#include "util_strings.h"

char* nr_guzzle_create_async_context_name(const char* prefix, const zval* obj) {
  if (!nr_php_is_zval_valid_object(obj)) {
    return NULL;
  }

  return nr_formatf("%s #%d", prefix, Z_OBJ_HANDLE_P(obj));
}

static int nr_guzzle_stack_iterator(zval* frame,
                                    int* in_guzzle_ptr,
                                    zend_hash_key* key NRUNUSED TSRMLS_DC) {
  int idx;
  zval* klass = NULL;

  NR_UNUSED_TSRMLS;

  if (0 == nr_php_is_zval_valid_array(frame)) {
    return ZEND_HASH_APPLY_KEEP;
  }
  if (NULL == in_guzzle_ptr) {
    return ZEND_HASH_APPLY_KEEP;
  }

  klass = nr_php_zend_hash_find(Z_ARRVAL_P(frame), "class");

  if (0 == nr_php_is_zval_non_empty_string(klass)) {
    return ZEND_HASH_APPLY_KEEP;
  }

  idx = nr_strncaseidx(Z_STRVAL_P(klass), "guzzle", Z_STRLEN_P(klass));
  if (idx >= 0) {
    *in_guzzle_ptr = 1;
  }

  return ZEND_HASH_APPLY_KEEP;
}

int nr_guzzle_in_call_stack(TSRMLS_D) {
  int in_guzzle = 0;
  zval* stack = NULL;

  if (0 == NRINI(guzzle_enabled)) {
    return 0;
  }

  stack = nr_php_backtrace(TSRMLS_C);

  if (nr_php_is_zval_valid_array(stack)) {
    nr_php_zend_hash_zval_apply(Z_ARRVAL_P(stack),
                                (nr_php_zval_apply_t)nr_guzzle_stack_iterator,
                                &in_guzzle TSRMLS_CC);
  }

  nr_php_zval_free(&stack);

  return in_guzzle;
}

int nr_guzzle_does_zval_implement_has_emitter(zval* obj TSRMLS_DC) {
  return nr_php_object_instanceof_class(
      obj, "GuzzleHttp\\Event\\HasEmitterInterface" TSRMLS_CC);
}

nr_segment_t* nr_guzzle_obj_add(const zval* obj,
                                const char* async_context_prefix TSRMLS_DC) {
  nr_segment_t* segment = NULL;
  char* async_context = NULL;
  int old_context = 0;

  /*
   * Create the async context, in case there was parallelism.
   */
  async_context
      = nr_guzzle_create_async_context_name(async_context_prefix, obj);
  /*
   * This is a special case where we don't want the context of the newly
   * created segment to be set on the txn because this segment is tracked
   * separately based off of the unique created guzzle async context. We need to
   * save the actual context so we can restore it later.
   */
  old_context = NRTXN(current_async_context);

  /*
   * Must explicitly be parented to the current segment of the txn context;
   * otherwise, it will be parented to the main NULL context. In non-fiber
   * cases, this will be a segment on the default (NULL) context; otherwise, it
   * will be the current segment on the actively executing fiber.
   *
   * Similar to curl_multi_exec curl handle segments, because async guzzle
   * segments are stored separately in a hashmap, we don't want to this segment
   * creation to affect the txn context.
   */

  segment = nr_segment_start(NRPRG(txn),
                             nr_txn_get_current_segment_txn_context(NRPRG(txn)),
                             async_context);

  nr_free(async_context);
  NRTXN(current_async_context) = old_context;

  /*
   * Create the guzzle_objs hash table if we haven't already done so.
   */
  if (NULL == NRTXNGLOBAL(guzzle_objs)) {
    NRTXNGLOBAL(guzzle_objs) = nr_hashmap_create(NULL);
  }

  /*
   * We store the start times indexed by the object handle for the Request
   * object: Zend object handles are unsigned ints while HashTable objects
   * support unsigned longs as indexes, so this is safe regardless of
   * architecture, and saves us having to transform the object handle into a
   * string to use string keys.
   */

  nr_hashmap_index_update(NRTXNGLOBAL(guzzle_objs),
                          (uint64_t)Z_OBJ_HANDLE_P(obj), segment);

  return segment;
}

nr_status_t nr_guzzle_obj_find_and_remove(const zval* obj,
                                          nr_segment_t** segment_ptr
                                              TSRMLS_DC) {
  if (NULL != NRTXNGLOBAL(guzzle_objs)) {
    uint64_t index = (uint64_t)Z_OBJ_HANDLE_P(obj);
    nr_segment_t* segment = NULL;

    segment
        = (nr_segment_t*)nr_hashmap_index_get(NRTXNGLOBAL(guzzle_objs), index);
    *segment_ptr = segment;

    if (segment) {
      /*
       * Remove the object handle from the hashmap containing active requests.
       */
      nr_hashmap_index_delete(NRTXNGLOBAL(guzzle_objs), index);

      return NR_SUCCESS;
    }
  }

  nrl_verbosedebug(NRL_INSTRUMENT,
                   "Guzzle: object %d not found in tracked list",
                   Z_OBJ_HANDLE_P(obj));
  return NR_FAILURE;
}

/*
 * Purpose : Sets a header on an object implementing either the Guzzle 3 or 4
 *           MessageInterface.
 *
 * Params  : 1. The header to set.
 *           2. The value to set the header to.
 *           3. The request object.
 */
static void nr_guzzle_request_set_header(const char* header,
                                         const char* value,
                                         zval* request TSRMLS_DC) {
  zval* header_param = NULL;
  zval* retval = NULL;
  zval* value_param = NULL;

  if ((NULL == header) || (NULL == value) || (NULL == request)) {
    return;
  }

  header_param = nr_php_zval_alloc();
  nr_php_zval_str(header_param, header);
  value_param = nr_php_zval_alloc();
  nr_php_zval_str(value_param, value);

  retval = nr_php_call(request, "setHeader", header_param, value_param);

  nr_php_zval_free(&header_param);
  nr_php_zval_free(&retval);
  nr_php_zval_free(&value_param);
}

void nr_guzzle_request_set_outbound_headers(zval* request,
                                            nr_segment_t* segment TSRMLS_DC) {
  nr_hashmap_t* outbound_headers = NULL;
  nr_vector_t* header_keys = NULL;
  char* header = NULL;
  char* value = NULL;
  size_t i;
  size_t header_count;

  outbound_headers = nr_header_outbound_request_create(NRPRG(txn), segment);

  if (NULL == outbound_headers) {
    return;
  }

  if (NRPRG(txn) && NRTXN(special_flags.debug_cat)) {
    nrl_verbosedebug(
        NRL_CAT,
        "CAT: outbound request: transport='Guzzle' %s=" NRP_FMT " %s=" NRP_FMT,
        X_NEWRELIC_ID,
        NRP_CAT((char*)nr_hashmap_get(outbound_headers, X_NEWRELIC_ID,
                                      nr_strlen(X_NEWRELIC_ID))),
        X_NEWRELIC_TRANSACTION,
        NRP_CAT((char*)nr_hashmap_get(outbound_headers, X_NEWRELIC_TRANSACTION,
                                      nr_strlen(X_NEWRELIC_TRANSACTION))));
  }

  header_keys = nr_hashmap_keys(outbound_headers);
  header_count = nr_vector_size(header_keys);

  for (i = 0; i < header_count; i++) {
    header = nr_vector_get(header_keys, i);
    value = (char*)nr_hashmap_get(outbound_headers, header, nr_strlen(header));
    nr_guzzle_request_set_header(header, value, request TSRMLS_CC);
  }

  nr_vector_destroy(&header_keys);
  nr_hashmap_destroy(&outbound_headers);
}

char* nr_guzzle_response_get_header(const char* header,
                                    zval* response TSRMLS_DC) {
  zval* param = nr_php_zval_alloc();
  zval* retval = NULL;
  char* value = NULL;

  nr_php_zval_str(param, header);

  retval = nr_php_call(response, "getHeader", param);
  if (NULL == retval) {
    nrl_verbosedebug(NRL_INSTRUMENT,
                     "Guzzle: Response::getHeader() returned NULL");
  } else if (nr_php_is_zval_valid_string(retval)) {
    /*
     * Guzzle 4 and 5 return an empty string if the header could not be found.
     */
    if (Z_STRLEN_P(retval) > 0) {
      value = nr_strndup(Z_STRVAL_P(retval), Z_STRLEN_P(retval));
    }
  } else {
    nrl_verbosedebug(
        NRL_INSTRUMENT,
        "Guzzle: unexpected Response::getHeader() return of type %d",
        Z_TYPE_P(retval));
  }

  nr_php_zval_free(&param);
  nr_php_zval_free(&retval);

  return value;
}

NR_PHP_WRAPPER_START(nr_guzzle_client_construct) {
  int is_guzzle_45 = 0;
  zval* this_var = nr_php_scope_get(NR_EXECUTE_ORIG_ARGS TSRMLS_CC);

  (void)wraprec;
  NR_UNUSED_SPECIALFN;

  is_guzzle_45 = nr_guzzle_does_zval_implement_has_emitter(this_var TSRMLS_CC);
  nr_php_scope_release(&this_var);

  if (is_guzzle_45) {
    NR_PHP_WRAPPER_DELEGATE(nr_guzzle4_client_construct);
  } else {
    NR_PHP_WRAPPER_DELEGATE(nr_guzzle6_client_construct);
  }
}
NR_PHP_WRAPPER_END