Dynatrace | Integration between NeoLoad and Dynatrace OneAgent

Since you mentioned that you already use Dynatrace I would suggest to have a closer look at Dynatrace Openkit. It's maybe not exactly what you are searching for. But I used it successfully to monitor a Java-based rich client application and there seems to be also a JS-version of it available here. The focus of the library is more on user experience but you can easily track things like OS, screen width, product version, user ID and location (autom. detected from IP address). With actions you can track any kind of operation and add optional key value pairs.

I'm not sure what you exactly mean with distributed IPC tracing. With the libray you can at least track outgoing web requests. You can also add a header to web requests so that they can be correlated with transactions of a remote backend that is already monitored with Dynatrace.

The library does neither provide any network / disk montoring by default nor metrics. For the first you could add properties or events to an action. For the later you could maybe use the metrics API. I used properties on actions to track additional data like the size of a loaded document but I haven't used the metrics API yet. To my understanding the metrics should be chartable (incl. percentiles) like any other metric in Dynatrace.

You need to use echo -n when you're printing the beginning of each line, so it doesn't break the line before all the services.

Then echo a newline after all the services.

1. How GC finds those roots at all?

A JVM provides an internal (C / C++) API for finding the roots. The JVM knows where the Java stack frames are, were the static frames for Java each class are, where the live JNI object handles are, and so on. (It knows because it was involved in creating them, and keeps track of them.)

1. How GC can find local variables in the stack that are references to object and are not other type of variables.

The JVM keeps information for each method that says which cells in each stack frame are reference variables. The GC can figure out which method each stack frame corresponds to ... just like fillInStackTrace can.

(for instance constant)

That's not actually relevant. Constants (i.e. final fields) don't get special treatment.

1. Then how GC finds fields of those objects to create an accessible tree?

The JVM keeps information for each class to say which of the static and instance fields are reference variables. There is an field in each object's header that refers to the class.

The whole process is called "marking", and it is described in the page you were looking at.

1. Does it use instruction that are defined by jvm itself to find those objects?

I'm not sure what you are asking. But "probably yes". The GC is a component of the JVM, so everything is does is "defined by the JVM".

1. And lastly what is the meaning of this sentence in the article?

This is not a real object virtual reference and thus is not visible

It might be saying that the thread's stack is not a Java object ... which is true. But I think you would need to ask the authors of that Ebook; see the bottom of https://www.dynatrace.com/resources/ebooks/javabook/ for their names.

You added this:

In JVM specification local variables in the frames of stack have no type and it's just somehow an array of bytes and it's the responsibility of compiler to generate type specific instruction for those local variables for instance iload, fload, aload, etc. So clearly GC can not find references to object by only looking at local variable section of the stack frames.

Actually, that is not true. As @Holder reminded me, the verifier infers the types of the cells in the stackframe by simulating the effects of the bytecodes that initialize them. In addition, each method in a classfile has a StackMapTable attribute containing information that is used to assist (and speed up) the verifier's type determination.

Later on, the GC can obtain the inferred type information from the JVM.

^{(In theory the GC could also make use of the StackMapTable information to determine when local variables go out of scope ... within a method. But apparently it doesn't in HotSpot JVMs; see Does the StackMapTable affect the garbage collection behavior?)}

The description of garbage collection in that Ebook is (deliberately) brief and high level. But that is true of most descriptions that you will find. The deep details are complicated.

If your really want (and need) to understand how GC's work, my advice is:

• To find out how the current Java implementations work read the OpenJDK source code.
• Track down and read the Sun and Oracle research papers on Java GCs.
• Get hold of a copy of a good textbook on Garbage Collection.

You can periodically send the metrics to Dynatrace as "custom metric", see the documentation.

Note: You cannot send historical values this way, you will send the "current" value periodically to continuously fill the timeseries.

Naturally you can send this much more often than daily, up to seconds-resolution if necessary and then you will get the chart in full resolution.

Then you can use custom charting to chart the metric and "pin" it onto a Dashboard.

• first, A typical memory representation of C program consists of following sections. (https://www.geeksforgeeks.org/memory-layout-of-c-program/)

There are two possible reasons for the self time of 13.5 seconds:

1. The body of the request or response headers were quite big and the transfer of the data took most of the time. Switch to "Summary" and check the body and header size.
2. Majority of the time was spend in IIS modules (e.g. authentication, compression) before/after the request was handled. Switch to Response Time Analysis, there you should see the time spend in IIS modules at the bottom of the screen.

You need some extra spaces in your query string.

For instance, these two lines:

Dynatracing claims to integrate seamlessly with OpenTracing https://www.dynatrace.com/integrations/opentracing/ and if you use the library you mentioned and if you have your HTTP part instrumented with OpenTracing, it will work out of the box.

The only potential drawback that in the service that hosts gets an HTTP call and within the context of handling it sends or publishes a message via MassTransit, everything must be instrumented with OpenTracing, because it will start the child span using the OpenTracing API.

We do this with Datadog, so we use the Datadog OpenTracing integration library and trace the WebApi and HttpClient using OpenTracing Contrib libraries. So, the automatic instrumentation didn't work for us. But it's not hard to use those libs to instrument your app instead of using the automatic instrumentation.

The usual flow is like:

• Outside -> WebApi: start a span
• WebApi -> MassTransit: start a child span, inject the context to headers
• MassTransit -> consumer: extract the context, start a child span and so on

Both bits with injection and extraction are handled in the MassTransit.OpenTracing library, so, there's nothing extra to do.

With a library that your provider has to support OpenTracing it's usually like this:

• Configure the tracer of the provider
• Set the OpenTracing global tracer to the wrapper, using the integration library from your provider
• When you create a span with OpenTracing, it will create a vendor-specific span and wrap it in OpenTracing span

So, the auth token is generated from your gcloud init authorization, which is end-user credentials. That's why you're getting that warning. Because you've used your manually signed in credentials to generate the token.

The preferred way to auth is to use a service account (documentation here: https://cloud.google.com/iam/docs/service-accounts) for authentication. That documentation will also walk you through creating a service account. If you're using it to talk to Firestore, your service account will need appropriate Firestore role permissions. Not to confuse you, but the roles in IAM are for datastore although they apply for Firestore.

This page: https://cloud.google.com/firestore/docs/security/iam lists out which roles/permissions your service account will need in order to do various things with Firestore.

Now, all that being said, the key-file it's talking about is the service account key that you can download when you create the service account. Easiest is to do it via the console in your GCP project, as when you're creating the service account, there's a handy button to create the key, and it downloads it to your local machine.