probes.d

   1 /* -*- c -*- */
   2 #include "vm_opts.h"
   3
   4 provider ruby {
   5   /*
   6      ruby:::method-entry(classname, methodname, filename, lineno);
   7
   8      This probe is fired just before a method is entered.
   9
  10      * `classname` name of the class (a string)
  11      * `methodname` name of the method about to be executed (a string)
  12      * `filename` the file name where the method is _being called_ (a string)
  13      * `lineno` the line number where the method is _being called_ (an int)
  14   */
  15   probe method__entry(const char *classname, const char *methodname, const char *filename, int lineno);
  16   /*
  17      ruby:::method-return(classname, methodname, filename, lineno);
  18
  19      This probe is fired just after a method has returned. The arguments are
  20      the same as "ruby:::method-entry".
  21   */
  22   probe method__return(const char *classname, const char *methodname, const char *filename, int lineno);
  23
  24   /*
  25      ruby:::cmethod-entry(classname, methodname, filename, lineno);
  26
  27      This probe is fired just before a C method is entered. The arguments are
  28      the same as "ruby:::method-entry".
  29   */
  30   probe cmethod__entry(const char *classname, const char *methodname, const char *filename, int lineno);
  31   /*
  32      ruby:::cmethod-return(classname, methodname, filename, lineno);
  33
  34      This probe is fired just before a C method returns. The arguments are
  35      the same as "ruby:::method-entry".
  36   */
  37   probe cmethod__return(const char *classname, const char *methodname, const char *filename, int lineno);
  38
  39   /*
  40      ruby:::require-entry(requiredfile, filename, lineno);
  41
  42      This probe is fired on calls to `rb_require_safe` (when a file is
  43      required).
  44
  45      * `requiredfile` is the name of the file to be required (string).
  46      * `filename` is the file that called "require" (string).
  47      * `lineno` is the line number where the call to require was made (int).
  48   */
  49   probe require__entry(const char *rquiredfile, const char *filename, int lineno);
  50
  51   /*
  52      ruby:::require-return(requiredfile, filename, lineno);
  53
  54      This probe is fired just before `rb_require_safe` (when a file is required)
  55      returns.  The arguments are the same as "ruby:::require-entry".  This
  56      probe will not fire if there was an exception during file require.
  57   */
  58   probe require__return(const char *requiredfile, const char *filename, int lineno);
  59
  60   /*
  61      ruby:::find-require-entry(requiredfile, filename, lineno);
  62
  63      This probe is fired right before `search_required` is called.
  64      `search_required` determines whether the file has already been required by
  65      searching loaded features ($"), and if not, figures out which file must be
  66      loaded.
  67
  68      * `requiredfile` is the file to be required (string).
  69      * `filename` is the file that called "require" (string).
  70      * `lineno` is the line number where the call to require was made (int).
  71   */
  72   probe find__require__entry(const char *requiredfile, const char *filename, int lineno);
  73
  74   /*
  75      ruby:::find-require-return(requiredfile, filename, lineno);
  76
  77      This probe is fired right after `search_required` returns.  See the
  78      documentation for "ruby:::find-require-entry" for more details.  Arguments
  79      for this probe are the same as "ruby:::find-require-entry".
  80   */
  81   probe find__require__return(const char *requiredfile, const char *filename, int lineno);
  82
  83   /*
  84      ruby:::load-entry(loadedfile, filename, lineno);
  85
  86      This probe is fired when calls to "load" are made.  The arguments are the
  87      same as "ruby:::require-entry".
  88   */
  89   probe load__entry(const char *loadedfile, const char *filename, int lineno);
  90
  91   /*
  92      ruby:::load-return(loadedfile, filename, lineno);
  93
  94      This probe is fired when "load" returns.  The arguments are the same as
  95      "ruby:::load-entry".
  96   */
  97   probe load__return(const char *loadedfile, const char *filename, int lineno);
  98
  99   /*
 100      ruby:::raise(classname, filename, lineno);
 101
 102      This probe is fired when an exception is raised.
 103
 104      * `classname` is the class name of the raised exception (string)
 105      * `filename` the name of the file where the exception was raised (string)
 106      * `lineno` the line number in the file where the exception was raised (int)
 107   */
 108   probe raise(const char *classname, const char *filename, int lineno);
 109
 110   /*
 111      ruby:::object-create(classname, filename, lineno);
 112
 113      This probe is fired when an object is about to be allocated.
 114
 115       * `classname` the class of the allocated object (string)
 116       * `filename` the name of the file where the object is allocated (string)
 117       * `lineno` the line number in the file where the object is allocated (int)
 118   */
 119   probe object__create(const char *classname, const char *filename, int lineno);
 120
 121   /*
 122      ruby:::array-create(length, filename, lineno);
 123
 124      This probe is fired when an Array is about to be allocated.
 125
 126       * `length` the size of the array (long)
 127       * `filename` the name of the file where the array is allocated (string)
 128       * `lineno` the line number in the file where the array is allocated (int)
 129   */
 130   probe array__create(long length, const char *filename, int lineno);
 131
 132   /*
 133      ruby:::hash-create(length, filename, lineno);
 134
 135      This probe is fired when a Hash is about to be allocated.
 136
 137       * `length` the size of the hash (long)
 138       * `filename` the name of the file where the hash is allocated (string)
 139       * `lineno` the line number in the file where the hash is allocated (int)
 140   */
 141   probe hash__create(long length, const char *filename, int lineno);
 142
 143   /*
 144      ruby:::string-create(length, filename, lineno);
 145
 146      This probe is fired when a String is about to be allocated.
 147
 148       * `length` the size of the string (long)
 149       * `filename` the name of the file where the string is allocated (string)
 150       * `lineno` the line number in the file where the string is allocated (int)
 151   */
 152   probe string__create(long length, const char *filename, int lineno);
 153
 154   /*
 155      ruby:::symbol-create(str, filename, lineno);
 156
 157      This probe is fired when a Symbol is about to be allocated.
 158
 159       * `str` the contents of the symbol (string)
 160       * `filename` the name of the file where the string is allocated (string)
 161       * `lineno` the line number in the file where the string is allocated (int)
 162   */
 163   probe symbol__create(const char *str, const char *filename, int lineno);
 164
 165   /*
 166      ruby:::parse-begin(sourcefile, lineno);
 167
 168      Fired just before parsing and compiling a source file.
 169
 170      * `sourcefile` the file being parsed (string)
 171      * `lineno` the line number where the source starts (int)
 172   */
 173   probe parse__begin(const char *sourcefile, int lineno);
 174
 175   /*
 176      ruby:::parse-end(sourcefile, lineno);
 177
 178      Fired just after parsing and compiling a source file.
 179
 180      * `sourcefile` the file being parsed (string)
 181      * `lineno` the line number where the source ended (int)
 182   */
 183   probe parse__end(const char *sourcefile, int lineno);
 184
 185 #if VM_COLLECT_USAGE_DETAILS
 186   probe insn(const char *insns_name);
 187   probe insn__operand(const char *val, const char *insns_name);
 188 #endif
 189
 190   /*
 191      ruby:::gc-mark-begin();
 192
 193      Fired at the beginning of a mark phase.
 194   */
 195   probe gc__mark__begin();
 196
 197   /*
 198      ruby:::gc-mark-end();
 199
 200      Fired at the end of a mark phase.
 201   */
 202   probe gc__mark__end();
 203
 204   /*
 205      ruby:::gc-sweep-begin();
 206
 207      Fired at the beginning of a sweep phase.
 208   */
 209   probe gc__sweep__begin();
 210
 211   /*
 212      ruby:::gc-sweep-end();
 213
 214      Fired at the end of a sweep phase.
 215   */
 216   probe gc__sweep__end();
 217 };
 218
 219 #pragma D attributes Stable/Evolving/Common provider ruby provider
 220 #pragma D attributes Stable/Evolving/Common provider ruby module
 221 #pragma D attributes Stable/Evolving/Common provider ruby function
 222 #pragma D attributes Evolving/Evolving/Common provider ruby name
 223 #pragma D attributes Evolving/Evolving/Common provider ruby args