Capturing Arguments with Native ADK deep in C / C++ Code

hi Christian,

reason for this is simple: argument & return value capturing are based on the same mechanism, the only difference is that arguments are sent with the method enter event and return values with the method exit event. implication of this is that arguments can only be captured at the start of a method and return values (obviously) only at the end of a method.

so in your case the method enter event is already sent at DYNATRACE_ENTER_CAPTURE(), so the captured long_var is sent with the next event, which is the method exit in your case and so it's treated as the return value here.

this is the reason why you should only capture arguments & return values immediately before sending enter/exit events. and that's also why we introduced those macros which capture arguments/return values together with DYNATRACE_ENTER/_EXIT.

bottom line: you can capture the long_var out of this ComplexType as argument, if you extract and capture it before DYNATRACE_ENTER. but the current behavior is as intended.

hope this helps,

Christian

Hi Christian,

that explains it. Too bad that i cant capture (in this particular case) anything useful from the Methods Entry Point directly as the Argument is a pointer to a XML Document which, in subsequent code, gets deconstructed. So placing the DYNATRACE_ENTER_CAPTURE deeper within the code at the  Point where i have extracted the relevant Node Information would loose the Tracing Informations regarding the deconstruction of the XML.

Thanks for the explanation and enlightnment.

You may consider putting another DYNATRACE_ENTER_CAPTURE into your code after parsing the XML input. So you won't lose the trace (i.e. the timing information of the method itself) and have the arguments as "dummy" call inside the actual method call:

void func_call (ComplexType fooArg) {
  DYNATRACE_API("STUFF");
  DYNATRACE_ENTER();
 
  code
  code
  more code
  
  { // IMPORTANT: note the additional block here
    DYNATRACE_ENTER_CAPTURE(
      DYNATRACE_CAPTURE_INT64(long_var);
    );
    more code
    even more code
    some more code
    
    // leave internal 'dummy' call - put the EXIT *before* leaving the block
    DYNATRACE_EXIT();
  }
  // leave the actual call
  DYNATRACE_EXIT();
}

The "inner" call will have the same method name, but will have the captured arguments. In the PurePath tree view it will appear as:

(M) func_call()
 +  (M) func_call(long)      <arg value> ...

Best regards,
Bernhard

Thats a very good suggestion, thanks. I will try it that way.