first round of fixes after initial testing

Author: lavarou

agent/fw_drupal8.c

@@ -140,22 +140,26 @@ static void nr_drupal8_add_method_callback_before_after_clean(
     nrspecialfn_t after_callback,
     nrspecialfn_t clean_callback) {
   zend_function* function = NULL;
+  char* methodLC = NULL;
 
   if (NULL == ce) {
     nrl_verbosedebug(NRL_FRAMEWORK, "Drupal 8: got NULL class entry in %s",
                      __func__);
     return;
   }
 
-  function = nr_php_find_class_method(ce, method);
+  methodLC = nr_string_to_lowercase(method);
+  function = nr_php_find_class_method(ce, methodLC);
   if (NULL == function) {
     nrl_verbosedebug(NRL_FRAMEWORK,
                      "Drupal 8+: cannot get zend_function entry for %.*s::%.*s",
                      NRSAFELEN(nr_php_class_entry_name_length(ce)),
                      nr_php_class_entry_name(ce), NRSAFELEN(method_len),
                      method);
+    nr_free(methodLC);
     return;
   }
+  nr_free(methodLC);
 
   if (NULL == nr_php_get_wraprec(function)) {
     char* class_method = nr_formatf(
@@ -167,6 +171,8 @@ static void nr_drupal8_add_method_callback_before_after_clean(
         clean_callback);
 
     nr_free(class_method);
+  } else {
+    nrl_always("%s::%s already has wraprec", nr_php_class_entry_name(ce), method);
   }
 }
 #endif  // OAPI
@@ -640,7 +646,7 @@ NR_PHP_WRAPPER(nr_drupal8_module_handler) {
 #if ZEND_MODULE_API_NO >= ZEND_8_0_X_API_NO \
     && !defined OVERWRITE_ZEND_EXECUTE_DATA
   nr_drupal8_add_method_callback_before_after_clean(
-      ce, NR_PSTR("invokeallwith"), nr_drupal94_invoke_all_with,
+      ce, NR_PSTR("invokeAllWith"), nr_drupal94_invoke_all_with,
       nr_drupal94_invoke_all_with_after, nr_drupal94_invoke_all_with_clean);
 #else
   nr_drupal8_add_method_callback(ce, NR_PSTR("invokeallwith"),

agent/php_execute.c

@@ -611,11 +611,11 @@ void nr_php_show_exec(const char* context, NR_EXECUTE_PROTO TSRMLS_DC) {
   const char* function_name = nr_php_op_array_function_name(NR_OP_ARRAY);
   const char* ctx = context ? context : "execute";
 #if ZEND_MODULE_API_NO >= ZEND_7_4_X_API_NO
-  #if ZEND_MODULE_API_NO >= ZEND_8_0_X_API_NO
-  nruserfn_t* wr = nr_php_get_wraprec_from_op_array_extension(__func__, execute_data->func);
-  #else
+  // #if ZEND_MODULE_API_NO >= ZEND_8_0_X_API_NO
+  // nruserfn_t* wr = nr_php_get_wraprec_from_op_array_extension(__func__, execute_data->func);
+  // #else
   nruserfn_t* wr = nr_php_get_wraprec(execute_data->func);
-  #endif
+  // #endif
 #endif
   argstr[0] = '\0';
 
@@ -1949,7 +1949,7 @@ static void nr_php_instrument_func_begin(NR_EXECUTE_PROTO) {
      */
     nr_php_observer_attempt_call_cufa_handler(NR_EXECUTE_ORIG_ARGS);
   }
-  wraprec = nr_php_get_wraprec_from_op_array_extension(__func__, execute_data->func);
+  wraprec = nr_php_get_wraprec(execute_data->func);
 
   segment = nr_segment_start(NRPRG(txn), NULL, NULL);
 

agent/php_minit.c

@@ -669,6 +669,9 @@ PHP_MINIT_FUNCTION(newrelic) {
   NR_ZEND_EXECUTE_HOOK = nr_php_execute;
 #else
   nr_php_observer_minit();
+  if (NR_SUCCESS != nr_php_user_instrument_wraprec_hashmap_init()) {
+    nrl_error(NRL_AGENT, "Failed to initialize user function instrumentation");
+  }
 #endif
 
   if (NR_PHP_PROCESS_GLOBALS(instrument_internal)) {

agent/php_observer.c

@@ -23,6 +23,7 @@
 #include "php_observer.h"
 #include "php_samplers.h"
 #include "php_user_instrument.h"
+#include "php_user_instrument_wraprec_hashmap.h"
 #include "php_vm.h"
 #include "php_wrapper.h"
 #include "fw_laravel.h"
@@ -75,6 +76,7 @@
 static zend_observer_fcall_handlers nr_php_fcall_register_handlers(
     zend_execute_data* execute_data) {
   zend_observer_fcall_handlers handlers = {NULL, NULL};
+  zend_string *func_name = NULL, *scope_name = NULL;
   nruserfn_t* wr;
   if (NULL == execute_data) {
     return handlers;
@@ -88,9 +90,34 @@ static zend_observer_fcall_handlers nr_php_fcall_register_handlers(
     nr_php_show_exec("observe", execute_data, NULL);
   }
 
-  wr = nr_php_get_wraprec(execute_data->func);
-  // store the wraprec in the op_array extension for the duration of the request for later lookup
-  ZEND_OP_ARRAY_EXTENSION(&execute_data->func->op_array, NR_PHP_PROCESS_GLOBALS(op_array_extension_handle)) = wr;
+  if (OP_ARRAY_IS_A_METHOD(&execute_data->func->op_array)) {
+    scope_name = execute_data->func->op_array.scope->name;
+    func_name = execute_data->func->op_array.function_name;
+#if 1
+    zend_long cn_hash = zend_hash_func(ZSTR_VAL(scope_name), ZSTR_LEN(scope_name));
+    zend_long fn_hash = zend_hash_func(ZSTR_VAL(func_name), ZSTR_LEN(func_name));
+    nrl_always("class_name=%s, class_name->h=%zu, cn_hash=%zu, function_name=%s, function_name->h=%zu, fn_hash=%zu",
+                ZSTR_VAL(scope_name), scope_name->h, cn_hash,
+                ZSTR_VAL(func_name), func_name->h, fn_hash);
+#endif
+  } else if (OP_ARRAY_IS_A_FUNCTION(&execute_data->func->op_array)){
+    func_name = execute_data->func->op_array.function_name;
+#if 1
+    zend_long fn_hash = zend_hash_func(ZSTR_VAL(func_name), ZSTR_LEN(func_name));
+    nrl_always("function_name=%s, function_name->h=%zu, fn_hash=%zu", ZSTR_VAL(func_name), func_name->h, fn_hash);
+#endif
+  }
+
+  if (!ZEND_OP_ARRAY_EXTENSION(&execute_data->func->op_array, NR_PHP_PROCESS_GLOBALS(op_array_extension_handle))) {
+    nrl_always("wraprec not installed yet");
+    wr = nr_php_user_instrument_wraprec_hashmap_get(func_name, scope_name);
+    nrl_always("found wraprec=%p", wr);
+
+    // store the wraprec in the op_array extension for the duration of the request for later lookup
+    ZEND_OP_ARRAY_EXTENSION(&execute_data->func->op_array, NR_PHP_PROCESS_GLOBALS(op_array_extension_handle)) = wr;
+  } else {
+    nrl_always("wraprec already installed");
+  }
 
   handlers.begin = nr_php_observer_fcall_begin;
   handlers.end = nr_php_observer_fcall_end;

agent/php_rinit.c

@@ -54,7 +54,9 @@ PHP_RINIT_FUNCTION(newrelic) {
   NRPRG(sapi_headers) = NULL;
   NRPRG(error_group_user_callback).is_set = false;
 #if ZEND_MODULE_API_NO >= ZEND_7_4_X_API_NO
+#if ZEND_MODULE_API_NO == ZEND_7_4_X_API_NO
   nr_php_init_user_instrumentation();
+#endif
 #if ZEND_MODULE_API_NO >= ZEND_8_0_X_API_NO \
     && !defined OVERWRITE_ZEND_EXECUTE_DATA
   NRPRG(drupal_http_request_segment) = NULL;

agent/php_user_instrument.c

@@ -7,6 +7,7 @@
 #include "php_globals.h"
 #include "php_user_instrument.h"
 #include "php_user_instrument_hashmap.h"
+#include "php_user_instrument_wraprec_hashmap.h"
 #include "php_wrapper.h"
 #include "lib_guzzle_common.h"
 #include "util_logging.h"
@@ -114,7 +115,32 @@ int nr_zend_call_orig_execute_special(nruserfn_t* wraprec,
   return zcaught;
 }
 
-#if ZEND_MODULE_API_NO >= ZEND_7_4_X_API_NO
+#if ZEND_MODULE_API_NO >= ZEND_8_0_X_API_NO
+static inline void nr_php_wraprec_lookup_set(nruserfn_t* wr,
+                                             zend_function* zf) {
+  // for situation when wraprec is added after first execution of the function
+  // store the wraprec in the op_array extension for the duration of the request for later lookup
+  // The op_array extension slot for function may not be initialized yet because it is
+  // initialized only on the first call made to the function in that request. This would
+  // mean that run_time_cache is NULL and wraprec cannot be stored yet! It will be stored
+  // on the first call to the function when observer is registered for that function.
+  if (NULL != RUN_TIME_CACHE(&zf->op_array)) {
+    ZEND_OP_ARRAY_EXTENSION(&zf->op_array, NR_PHP_PROCESS_GLOBALS(op_array_extension_handle)) = wr;
+  }
+}
+
+static inline nruserfn_t* nr_php_wraprec_lookup_get(zend_function* zf) {
+  nruserfn_t *wraprec = NULL;
+  
+  if (NULL != RUN_TIME_CACHE(&zf->op_array)) {
+    wraprec = ZEND_OP_ARRAY_EXTENSION(&zf->op_array, NR_PHP_PROCESS_GLOBALS(op_array_extension_handle));
+  }
+  if (NULL != wraprec && NRPRG(pid) != wraprec->pid) {
+    wraprec = NULL;
+  }
+  return wraprec;
+}
+#elif ZEND_MODULE_API_NO == ZEND_7_4_X_API_NO
 /* Hashmap with pointers to wraprecs. Some, that are re-usable between requests,
  * are stored in linked list. These wraprecs are created once per interesting
  * function detection, and destroyed at module shutdown. Some, that are
@@ -130,17 +156,6 @@ static nr_php_wraprec_hashmap_t* user_function_wrappers;
 static inline void nr_php_wraprec_lookup_set(nruserfn_t* wr,
                                              zend_function* zf) {
   nr_php_wraprec_hashmap_update(user_function_wrappers, zf, wr);
-#if ZEND_MODULE_API_NO >= ZEND_8_0_X_API_NO /* PHP 8.0+ */
-  // for situation when wraprec is added after first execution of the function
-  // store the wraprec in the op_array extension for the duration of the request for later lookup
-  // The op_array extension slot for function may not be initialized yet because it is
-  // initialized only on the first call made to the function in that request. This would
-  // mean that run_time_cache is NULL and wraprec cannot be stored yet! It will be stored
-  // on the first call to the function when observer is registered for that function.
-  if (NULL != RUN_TIME_CACHE(&zf->op_array)) {
-    ZEND_OP_ARRAY_EXTENSION(&zf->op_array, NR_PHP_PROCESS_GLOBALS(op_array_extension_handle)) = wr;
-  }
-#endif
 }
 static inline nruserfn_t* nr_php_wraprec_lookup_get(zend_function* zf) {
   nruserfn_t* wraprec = NULL;
@@ -306,6 +321,7 @@ nruserfn_t* nr_php_user_wraprec_create(void) {
   return wr;
 }
 
+#if ZEND_MODULE_API_NO < ZEND_8_0_X_API_NO
 static nruserfn_t* nr_php_user_wraprec_create_named(const char* full_name,
                                                     int full_name_len) {
   int i;
@@ -355,6 +371,7 @@ static nruserfn_t* nr_php_user_wraprec_create_named(const char* full_name,
 
   return wraprec;
 }
+#endif
 
 void nr_php_user_wraprec_destroy(nruserfn_t** wraprec_ptr) {
   nruserfn_t* wraprec;
@@ -377,6 +394,7 @@ void nr_php_user_wraprec_destroy(nruserfn_t** wraprec_ptr) {
   nr_realfree((void**)wraprec_ptr);
 }
 
+#if ZEND_MODULE_API_NO < ZEND_8_0_X_API_NO
 static int nr_php_user_wraprec_is_match(const nruserfn_t* w1,
                                         const nruserfn_t* w2) {
   if ((0 == w1) && (0 == w2)) {
@@ -393,11 +411,42 @@ static int nr_php_user_wraprec_is_match(const nruserfn_t* w1,
   }
   return 1;
 }
+#endif
+
+#if ZEND_MODULE_API_NO > ZEND_7_4_X_API_NO
+static nruserfn_t* nr_transient_wraprecs = NULL; /* a singly linked list */
+#else
+static nruserfn_t* nr_wrapped_user_functions = NULL; /* a singly linked list */
+#endif
 
 static void nr_php_add_custom_tracer_common(nruserfn_t* wraprec) {
   /* Add the wraprecord to the list. */
+#if ZEND_MODULE_API_NO > ZEND_7_4_X_API_NO
+  if (wraprec->is_transient) {
+    /* Transient (unnamed) wraprecs are not added to wraprec hashmap which only stores named
+     * wraprecs. Keep track of all transient wraprecs so that they can be destroyed at the
+     * end of the request. */
+    wraprec->next = nr_transient_wraprecs;
+    nr_transient_wraprecs = wraprec;
+    return;
+  }
+#endif
+#if ZEND_MODULE_API_NO == ZEND_7_4_X_API_NO
+  if (!wraprec->is_transient) {
+    /* Non-transient wraprecs are added to both the hashmap and linked list.
+     * At request shutdown, the hashmap will free transients, but leave
+     * non-transients to be freed when the linked list is disposed of which is at
+     * module shutdown */
+    wraprec->next = nr_wrapped_user_functions;
+    nr_wrapped_user_functions = wraprec;
+    return;
+  }
+#endif
+#if ZEND_MODULE_API_NO < ZEND_7_4_X_API_NO
   wraprec->next = nr_wrapped_user_functions;
   nr_wrapped_user_functions = wraprec;
+  return;
+#endif
 }
 
 #define NR_PHP_UNKNOWN_FUNCTION_NAME "{unknown}"
@@ -440,16 +489,15 @@ nruserfn_t* nr_php_add_custom_tracer_callable(zend_function* func TSRMLS_DC) {
   nr_free(name);
 
   nr_php_wrap_zend_function(func, wraprec TSRMLS_CC);
-#if ZEND_MODULE_API_NO < ZEND_7_4_X_API_NO
   nr_php_add_custom_tracer_common(wraprec);
-#endif
 
   return wraprec;
 }
 
 nruserfn_t* nr_php_add_custom_tracer_named(const char* namestr,
                                            size_t namestrlen) {
   nruserfn_t* wraprec;
+#if ZEND_MODULE_API_NO < ZEND_8_0_X_API_NO
   nruserfn_t* p;
 
   wraprec = nr_php_user_wraprec_create_named(namestr, namestrlen);
@@ -474,17 +522,15 @@ nruserfn_t* nr_php_add_custom_tracer_named(const char* namestr,
     }
     p = p->next;
   }
-
+#else
+  wraprec = nr_php_user_instrument_wraprec_hashmap_add(namestr, namestrlen);
+#endif
   nrl_verbosedebug(
       NRL_INSTRUMENT, "adding custom for '" NRP_FMT_UQ "%.5s" NRP_FMT_UQ "'",
       NRP_PHP(wraprec->classname),
       (0 == wraprec->classname) ? "" : "::", NRP_PHP(wraprec->funcname));
 
   nr_php_wrap_user_function_internal(wraprec TSRMLS_CC);
-  /* non-transient wraprecs are added to both the hashmap and linked list.
-   * At request shutdown, the hashmap will free transients, but leave
-   * non-transients to be freed when the linked list is disposed of which is at
-   * module shutdown */
   nr_php_add_custom_tracer_common(wraprec);
 
   return wraprec; /* return the new wraprec */
@@ -501,7 +547,13 @@ nruserfn_t* nr_php_add_custom_tracer_named(const char* namestr,
  *
  */
 void nr_php_reset_user_instrumentation(void) {
-#if ZEND_MODULE_API_NO >= ZEND_7_4_X_API_NO
+#if ZEND_MODULE_API_NO >= ZEND_8_0_X_API_NO
+  /* No need to do anything at rshutdown:
+   *  - Observer API takes care of resetting user instrumentation for each request
+   *  - All named wraprecs ever created persist in wraprec hashmap until mshutdown
+   */
+  return;
+#elif ZEND_MODULE_API_NO >= ZEND_7_4_X_API_NO
   // send a metric with the number of transient wrappers
   if (NULL != user_function_wrappers) {
     nr_php_wraprec_hashmap_stats_t stats
@@ -554,14 +606,16 @@ void nr_php_remove_transient_user_instrumentation(void) {
  * Wrap all the interesting user functions with instrumentation.
  */
 void nr_php_add_user_instrumentation(TSRMLS_D) {
-  nruserfn_t* p = nr_wrapped_user_functions;
+#if ZEND_MODULE_API_NO < ZEND_8_0_X_API_NO
+  nruserfn_t* p = nr_named_wraprecs;
 
   while (0 != p) {
     if ((0 == p->is_wrapped) && (0 == p->is_disabled)) {
       nr_php_wrap_user_function_internal(p TSRMLS_CC);
     }
     p = p->next;
   }
+#endif
 }
 
 void nr_php_add_transaction_naming_function(const char* namestr,
@@ -608,6 +662,7 @@ void nr_php_remove_exception_function(zend_function* func TSRMLS_DC) {
 }
 
 void nr_php_destroy_user_wrap_records(void) {
+#if ZEND_MODULE_API_NO < ZEND_8_0_X_API_NO
   nruserfn_t* next_user_wraprec;
 
   next_user_wraprec = nr_wrapped_user_functions;
@@ -618,15 +673,12 @@ void nr_php_destroy_user_wrap_records(void) {
     nr_php_user_wraprec_destroy(&wraprec);
   }
 
-  nr_wrapped_user_functions = NULL;
+  nr_named_wraprecs = NULL;
+#else
+  nr_php_user_instrument_wraprec_hashmap_destroy();
+#endif
 }
 
-/*
- * This is a similar list, but for the dynamically added user-defined functions
- * rather than the statically defined internal/binary functions above.
- */
-nruserfn_t* nr_wrapped_user_functions = 0;
-
 void nr_php_user_function_add_declared_callback(const char* namestr,
                                                 int namestrlen,
                                                 nruserfn_declared_t callback

agent/php_user_instrument.h

@@ -37,7 +37,7 @@ typedef void (*nruserfn_declared_t)(TSRMLS_D);
 typedef struct _nruserfn_t {
   struct _nruserfn_t* next; /* singly linked list next pointer */
 
-#if ZEND_MODULE_API_NO >= ZEND_7_4_X_API_NO
+#if ZEND_MODULE_API_NO == ZEND_7_4_X_API_NO
   /* wraprec hashmap key */
   nr_php_wraprec_hashmap_key_t key;
 #endif
@@ -111,9 +111,10 @@ typedef struct _nruserfn_t {
   int pid; /* pid of a process that created this wraprec */
 } nruserfn_t;
 
-extern nruserfn_t* nr_wrapped_user_functions; /* a singly linked list */
-
-#if ZEND_MODULE_API_NO >= ZEND_7_4_X_API_NO
+#if ZEND_MODULE_API_NO >= ZEND_8_0_X_API_NO
+/* PHPs 8.0+ use ZEND_OP_ARRAY_EXTENSION to store wraprecs and Observer API to install them */
+extern nruserfn_t* nr_php_get_wraprec(zend_function* zf);
+#elif ZEND_MODULE_API_NO == ZEND_7_4_X_API_NO
 
 /*
  * Purpose : Init user instrumentation. This must only be called on request