101 Flashcards
(225 cards)
1
Q
JRE
A
Acronym for Java Runtime Environment. All you need to run Java programs, but nothing else–notably, no compiler, so you cannot writeJava programs with only a JRE.
A reduced Java bundle that originally had easy redistribution rights. It was intended to be a shippable component for applications and provides a full JVM but no compilation and no utilities. For a long time it was not as commonly used as the JDK, but containerization is changing that as more and more people move toward using lean containers.
2
Q
JDK
A
Acronym for Java Development Kit. A JRE plus other tools, most notably a compiler.
A full Java bundle, including compilation (javac) and some useful utilities (tools.jar). It was originally intended for developers but lately more people use a JDK than a JRE because of the utilities.
3
Q
JVM
A
a running instance of Java or JRE process; in all of the major operating systems, a JVM is a running process
4
Q
Native code
A
code running in a JVM that is not Java code (typically it is written in a C variant). This code typically implements functionality that requires knowledge of underlying operating system capabilities, and therefore is not portable from (for example) Windows to Linux.
5
Q
Class loader
A
a Java class with specific native code capabilities that allow code to be loaded into a JVM.
A class loader is also an implied namespace: although there is no human-readable “name” associated with a class loader, a class with the same fully-qualified name in one class loader is different from a class with the same fully-qualified name in a different class loader. Those two classes would have different hashCodes, and they would not be “equals()” to each other.
6
Q
Classpath
A
similar to a PATH in Unix variants, a classpath is a concatenated set of file paths that form a precedence rule for loading Java code.
In Unix variants, if your PATH environment variable includes two entries where a command will be found, the command in the first entry in the PATH is the one used. The same is true for a classpath: if your classpath includes multiple entries containing the same fully-qualified class name, the one that appears first will be used. A lack of understanding of what code exists in each path entry can lead to confusion and also to using unexpected code.
7
Q
Fully-qualified name
A
a concatenation of package name, the “.” character, and classname. Also called fully-qualified class name and sometimes abbreviated fqcn.
8
Q
Hashcode
A
a Java hashcode is fundamentally no different than a hashcode in other languages –i.e. it describes an integer value calculated from attributes of a language construct (in Java, that’s an Objectas in java.lang.Object), and that value is typically used as a quick way to determine inequality.
In Java, if equals() == truefor any two objects, then it also MUST be true that the hashCode()values from the two objects are equal. The reverse is NOT NECESSARILY true: if two objects have the same hashCode()values, it is still possible (but unlikely, for a reasonably good hashing function) that the equals()is not true.NOTE: in Java code, the method name is always hashCode()(i.e. camel-case)
9
Q
Class
A
a Java object description.
In Java, there is a base java.lang.Object class from which every other class is extended. A class is represented on disk in a file format described inThe Java Virtual Machine Specification(Java 8 PDF version link). Classes have a simple name and a fully-qualified name. A class can be exactly one of abstract, concrete, or an interface. A class may also be an inner class or an anonymous inner class, those are orthogonal to whether the class is abstract, concrete or an interface. Finally, a class may also be an Enum class.
10
Q
Superclass
A
also called a parent class, a superclass has code that is implicitly present in subclasses and is there fore a building block for more complex functionality.
Since superclasses and subclasses form the foundation of object-oriented programming, it is absolutely critical that the concept of class hierarchies is understood. Understanding at least the basics of a class hierarchy directly affects your ability to configure BT detection and backend rules in AppD
11
Q
Subclass
A
also called a child class, a subclass has a functionality from the superclass plus additional functionality specified in the subclass itself
12
Q
Concrete class
A
a class where all declared methods have implementation code contained within the class. This means a concrete class can be instantiated
13
Q
Abstract class
A
a class with declared methods that have no implementations in the class. Instead the class depends on (REQUIRES actually) concrete subclasses to implement the specific methods. An abstract class cannot be directly instantiated.
14
Q
Enum
A
a specialised class that can only have very specific values. Enums are often used to describe known things like colour, gender - things th can be (duh!) enumerated
15
Q
Inner Class
A
a class whose definition lives in another class.
This is typically a code style choice done when the developer wants to separate some functionality, but that functionality is only related to a single other class–sort of a helper scenario. By using the inner class construct, the developer signals to others reading the code that the scope of the usefulness of the inner class is limited, so nobody needs to go off reading all sorts of other code to understand how the inner class is used. Inner class names have a “$” character separating the containing class name from the inner class name, so inner class FileParser in containing class Book would have the full name of Book$FileParser–you would need to know that in order to create any type of rule (BT, backend, MIDC, info point) rule using the inner class.
16
Q
Anonymous Class
A
a class with no name.
This is done in source code by specifying the code directly inline, with no containing class definition. This is a programming convention often used for callback-type functionality. An anonymous class is always inner, since there is no way to create one without some containing code structure. Anonymous inner class names are generated using an increasing numeric counter, so the first anonymous inner class (reading down from the top in source code) in class Book would be Book$1, then Book$2, etc.
It is perfectly legal to use anonymous inner classes in AppDynamics rules, but doing so is inherently fragile: if you declared a rule on inner class Book$3, and then some code was updated so that the Book source code added an anonymous inner class above (reading down from the top) the one you instrumented, then your instrumentation would break when the new code is compiled and deployed. Because of that, it is best to avoid using anonymous inner classes in rules if at all possible
17
Q
Interface
A
a class method description with no implementations at all. Interfaces are useful in specifications where the actual implementation is left to others.
18
Q
Package
A
a namespace for classes. Classes in the same package are compiled from source code in the same source directory structure on disk, and the package name is typically created from the last few segments of the directory path. This means that it is possible for classes in the same package to come from source code in different directories, as long as the directory names match from the sources root on downward
19
Q
Garbage Collection
A
a JVM capability for reclaiming memory that is no longer being used.
20
Q
OSGi
A
originally formed from the Open Services Gateway initiative, the expansion of the acronym has fallen out of favour, so now it really doesn’t stand for anything, it’s just the short name of the OSGi Alliance.
At a technical level, OSGi isa specification for bundling Java code that creates an alternative scheme to the standard classloading capabilities. OSGi was created out of frustration with the default Java classloading functionality and changes some default behaviour for what code is visible to other code.
For AppDynamics purposes, awareness of OSGi is important because it puts additional requirements on how our Java agent must be configured, and sometimes for what we can do in getter chains. Remember, the very purpose of OSGi was to create an alternate scheme for class bundling and loading; what this means in practice is that the standard rules of classpath resolution and classloader are being changed. OSGi was never bundled into standard JDK functionality, but a similar capability is going into Java 9 in the form of what is being called Modules
21
Q
JAR
A
“Java archive” –a specification for bundling Java code based on the Zip file format. A Jar file minimally contains Java classes and a Manifest.mf file containing meta-information. It may optionally contain other resources such as flat files, images, etc.
22
Q
War
A
“Web archive” –a specification for bundling Java code based on the Zip file format. A War file typically contains one or more Jar files, plus other descriptive information. A War file is the unit of deployment for a servlet container. In addition to Jar file contents, a War file contains a web deployment descriptor called web.xml, which maps Java servlet code to URL paths in the servlet container
23
Q
Ear
A
Enterprise archive” –a specification for bundling Java code based on the Zip file format. An Ear file typically contains one or more War and/or Jar files, plus other descriptive information. An Ear file is the unit of deployment for a J2EE-compliant application server. In addition to War file components, an Ear file may contain descriptors for EJB deployment
24
Q
Servlet container
A
a program whose primary functionality is to run Java servlets, but typically has less bundled features than a fully-compliant J2EE application server. A servlet container supports war files, but not ear files
25
Application server
a program with all the functionality of a servlet container, plus support for ear files,EJBs, database connection pools, and (often, but not required) Java messaging
26
J2EE
Java 2, Enterprise Edition. This refers to all of the functionality and code that exists in J2SE, plus some extension specifications that are typically in the javax package namespace.
The entire J2EE ecosystem is roughly comparable to the entire .NET ecosystem, whereas J2SEis more comparable to the core C# platform, without ASP, WCF, WPF, etc
27
J2SE
Java 2, Standard Edition. This refers to all of the functionality and code that exists in a JDK download bundle
28
Servlet
an early specification for standard web functionality. Servlets still dominate as the standard of choice for existing Java web functionality, but that is mostly a reflection of how long they have been around. Modern implementations bypass the servlet specification in favour of more efficient web implementations, which gives rise to the current explosion of alternate Java web platforms.
Servlets are detected OOTB by AppDynamics with default naming rules and a lot of flexibility for configuring custom naming schemes.
29
EJB
Enterprise Java Beans, a specification for creating components that have common capabilities for deployment and interoperability. EJB was the first specification for distributed Java computing, but has fallen out of favour to more modern, efficient implementations.
30
Reflection
the ability to invoke Java operations (i.e. methods) using information gained from introspection.
This capability is fundamental to the ability in AppDynamics to use getter chains. An AppDynamics getter chain is simply a text string that is used to find the corresponding Java class/method information (introspection) and then to use that information to invoke operations (reflection). In turn, getter chains are the fundamental building block used to create real-time business metrics, method invocation data collectors, BT and backend split rules, and ultimately Analytics information. Thus is the use of reflection that is behind all of the most powerful features in AppDynamics
31
thread (smaller t)
thread is also a hardware construct (processors can support threads), an operating system construct (all modern operating systems support threads at the operating system level) and even a JVM construct (especially true in earlier JVMs, which appeared at a time when operating system support for threads was lack luster). In practice you will probably never have to differentiate between hardware, OS or Java threads, so it is safe to simplify and view threads as two different things: Threads (the Java object) and threads (the hardware/OS/Java capability).
32
thread (smaller t)
thread is also a hardware construct (processors can support threads), an operating system construct (all modern operating systems support threads at the operating system level) and even a JVM construct (especially true in earlier JVMs, which appeared at a time when operating system support for threads was lack-luster). In practice you will probably never have to differentiate between hardware, OS or Java threads, so it is safe to simplify and view threads as two different things: Threads (the Java object) and threads (the hardware/OS/Java capability).
33
thread (smaller t)
thread is also a hardware construct (processors can support threads), an operating system construct (all modern operating systems support threads at the operating system level) and even a JVM construct (especially true in earlier JVMs, which appeared at a time when operating system support for threads was lack-luster). In practice you will probably never have to differentiate between hardware, OS or Java threads, so it is safe to simplify and view threads as two different things: Threads (the Java object) and threads (the hardware/OS/Java capability).
34
Executor
A specific Java implementation of asynchronous behaviour in the JDK. In the JDK an ExecutorService provides Executors, which are different implementations of thread pools.
35
Publish/Subscribe (Pub/Sub)
A loose coupling of two or more components whereby one "publishes" events or messages to some named service, and other components "subscribe" to the service, which means they receive events as they are published. Publishers and subscribers need not (and typically don't) know anything about each other.
36
Producer/consumer (blocking queue)
describes a tighter coupling than Pub/Sub, whereby the provider ("producer") of some resource feeds instances of the resource into some queue, whose size is typically capped. Consumers pull resources out of the queue. In the event of a full queue producers wait until one or more consumers creates space by consuming the resource. In the event of an empty queue consumers wait until one or more producers supply more resources needed.
37
Semaphore/Mutex
A construct in a code runtime that enables waiting and notification in asynchronous environments. In Java, any Object can act as the semaphore
38
Blocking
Suspension of code execution that happens when a thread of execution needs to acquire a semaphore, but cannot because other threads are doing the same thing. Blocking is distinct from waiting: when blocking occurs it is typically because there are too many threads trying to acquire the same semaphore. This may be an issue with code architecture, but it can also be a configuration problem if a threadpool size is configurable and set to a high value.
39
Waiting
Suspension of code execution that happens when a thread of execution needs to acquire a resource that is limited and currently not available. Waiting is distinct from blocking: when waiting occurs it is typically because too few critical resources are available. A very common cause of waiting is an undersized JDBC connection pool, or any other type of resource pool.
40
Reactive Programming
A style of asynchronous programming described in The Reactive Manifesto
Reactive programming is a programming paradigm that deals with asynchronous data streams (sequences of events) and the specific propagation of change, which means it implements modifications to the execution environment (context) in a certain order.
41
Fire and forget
A style of asynchronous programming whereby the instigator of an action "fires" (i.e. initiates the action) and then does not track execution or completion of the action ("forgets").
42
Fork/join
A style of asynchronous programming whereby the instigator of an action fires the action ("forks"), then does some other activity while the action is also completing independently, then waits for notification that the action is complete ("joins").
43
Thread profiler
A dynamic service in the Java agent that is useful for understanding the behaviour of individual threads in an asynchronous environment.
Using the Thread Profiler Dynamic Service early in a POV with asynchronous functionality can greatly shorten the POV time.
Term related to using AppDynamics in asynchronous environments
44
BCT log
the ByteCodeTransformer log, this log shows every class loaded into the JVM and what (if any) instrumentation was applied. Understanding this log is crucial to diagnosing and fixing problems with over-instrumentation of asynchronous behaviour.
Term related to using AppDynamics in asynchronous environments
45
Async interceptor
The AppDynamics instrumentor for Runnable and Callable classes in Java. The BCT log has entries for async interceptors.
Term related to using AppDynamics in asynchronous environments
46
Activity Interceptor
Similar to the Async interceptor, but more general-case: the AppDynamics instrumentor for general asynchronous or cross-process behaviour. The BCT log has entries for activity interceptors.
Term related to using AppDynamics in asynchronous environments
47
fork-config
The section of app-agent-config.xml where adjustments to async interceptor config may be done – for example, in a situation where the goal is to exclude some classes from being instrumented with async interceptors.
Term related to using AppDynamics in asynchronous environments
48
fork-config
The section of app-agent-config.xml where adjustments to async interceptor config may be done – for example, in a situation where the goal is to exclude some classes from being instrumented with async interceptors.
Term related to using AppDynamics in asynchronous environments
49
Scala
A JVM language of choice for reactive programming. It is next to impossible to write any Scala code that is not asynchronous
50
Akka
A package in Scala (also Java) that supports reactive programming semantics using components called Actors
51
Spray
An asynchronous REST/HTTP framework for Akka actors
52
Play
An asynchronous web framework with Java and Scala APIs
53
Scala
A JVM language of choice for reactive programming, with distinct syntaxes that compile down to Java bytecode. It is next to impossible to write any Scala code that is not asynchronous
54
Akka
A package, component framework, in Scala and Java that encourages reactive programming style. Supports semantics using components called Actors
55
Netty
a low-level communications framework that supports some ESB semantics, plus web and messaging. Often other frameworks build on top of Netty, using it for the underlying networking functionality (both Play and Vert.x do this)
56
Play
An asynchronous, rapid- development, web framework with Java and Scala APIs
57
Groovy
A JVM language popularised by SpringSource (now Pivotal), , with distinct syntaxes that compile down to Java bytecode, that is more natural for async functionality than Java (but less so than Scala).
58
dequeue
Commonly-used name for methods in asynchronous environments.
"Hint" word that often indicate asynchronous functionality.
59
offer
Commonly-used name for methods in asynchronous environments.
"Hint" word that often indicate asynchronous functionality.
60
put
Commonly-used name for methods in asynchronous environments.
"Hint" word that often indicate asynchronous functionality.
61
take
Commonly-used name for methods in asynchronous environments.
"Hint" word that often indicate asynchronous functionality.
62
receive
Commonly-used name for methods in asynchronous environments.
"Hint" word that often indicate asynchronous functionality.
63
send
Commonly-used name for methods in asynchronous environments.
"Hint" word that often indicate asynchronous functionality.
64
publish
Commonly-used name for methods in asynchronous environments.
"Hint" word that often indicate asynchronous functionality.
65
subscribe
Commonly-used name for methods in asynchronous environments.
"Hint" word that often indicate asynchronous functionality.
66
poll
Commonly-used name for methods in asynchronous environments.
"Hint" word that often indicate asynchronous functionality.
67
onXXXEvent (where "XXX" can be almost any descriptive word describing the event)
Commonly-used name for methods in asynchronous environments.
"Hint" word that often indicate asynchronous functionality.
68
onXXXEvent (where "XXX" can be almost any descriptive word describing the event)
Commonly-used name for methods in asynchronous environments.
"Hint" word that often indicate asynchronous functionality.
69
True or False: BT response times only measure the response time for a single thread, not an entire asynchronous BT
true (use E2E latency for the entire async BT)
70
Why are some lines between Tiers solid and some dashed on the app flow map?
the dashed lines indicate asynchronous behaviour, whereas the solid ones indicate synchronous behaviour.
71
Do you support Spray with Scala?
Yes, but Spray is not supported as a first-class Web framework by AppD, meaning that BT detection will not be automatic, E2E detection will have to be configured, and there is a good chance some custom correlation might be needed. IOW, this is a complicated environment.
72
Do you support Spray with Scala?
Yes, but Spray is not supported as a first-class Web framework by AppD, meaning that BT detection will not be automatic, E2E detection will have to be configured, and there is a good chance some custom correlation might be needed. IOW, this is a complicated environment.
73
Hadoop
an Apache project, also available as a commercially-supported product of Cloudera
74
Spark
An Apache project
Apache Spark is an open-source unified analytics engine for large-scale data processing. Spark provides an interface for programming entire clusters with implicit data parallelism and fault tolerance.
75
Storm
An Apache project, also available as a commercially-supported product from Hortonworks
76
Kafka
An Apache project, also available as a commercially-supported product from Hortonworks
77
Zookeeper
ZooKeeper is an open source Apache project that provides a centralized service for providing configuration information, naming, synchronization and group services over large clusters in distributed systems.
The goal is to make these systems easier to manage with improved, more reliable propagation of changes.
78
Cassandra
A database technology popular in Big Data platforms
79
HBase
default databse in Hadoop
80
Mesos
A resource negotiator, used by Zookeeper to ensure high availability in a big data platform
81
Apache Tarn
(not to be confused with Node.js Yarn packaging tool)
A resource negotiator, an alternate technology to Mesos
82
What kind of metrics can we see with Storm?
Storm exposes many JMX metrics, which we can configure for capture in AppDynamics and show on dashboards.
83
The customer informs you that their application is using some fancy classloader logic, and they want to detect BTs from classes in one specific class loader, even though the same class name is used in other class loaders. Is this possible?
Not without further information
84
You have discovered that the customer's environment uses an OSGi container. What is your next step?
OSGi configuration is well-documented in the docs site.
85
As of October, 2016, what must you do to configure the Java agent to work with modules?
Modules have not appeared in any JDK shipping as of 2016, so there is nothing to do – you won't see them until at least Java 9.
86
True or False: Java supports more than one type of classloading scheme
True
87
Relational Databases
row-oriented databases.
Strictly speaking, relational databases do not have to support SQL, but in practice all of them do
The common relational databases all have full OOTB support in AppDynamics, which gives metrics for connection pool usage and query times, as well as "sanitized" query text in snapshots. "Sanitized" refers to having the specific bind variable information hidden in the query text. Specific database products with full OOTB support include
Oracle
DB2
Sybase
PostgreSQL (aka "Postgres")
88
SQL
Structured query language, the language of all of the relevant relational databases
89
NoSQL
Non-relational databases, which come in many forms:
Column-oriented (Cassandra)
Document (CouchDB - apache, CouchBase- commercial, MongoDB)
Key/Value (Voldemort, Memcached, Gemfire, Ehcache)
Bigtable (Apache Hbase)
Graph (Neo, Orient DB)
90
Key/Value
Non-relational database, really just fancy distributed caches
91
Hibernate
the dominant object/relational mapper, used to accelerate application development with relational databases. The two most important things to know about Hibernate are
AppDynamics works very well with Hibernate, and
Customers using Hibernate frequently have performance problems caused by sub-optimal Hibernate configurations, which AppDynamics solves nicely
92
"Sanitized" query text
"Sanitized" refers to having the specific bind variable information hidden in the query text.
93
Specific relational database products with full OOTB support include
Oracle
DB2
Sybase
PostgreSQL (aka "Postgres")
94
NoSQL databases give less query-level information in snapshots: True or False
True, with the exception of Cassandra. There is some OOTB support for MongoDB and Cassandra as of AppDynamics 4.2, less so for other NoSQL databases.
95
How many of these databases are relational databases?
```
PostgreSQL
OrientDB
Cassandra
MongoDB
Oracle
```
2
96
How many of these databases are relational databases?
```
PostgreSQL
OrientDB
Cassandra
MongoDB
Oracle
```
2
97
NoSQL database technology is rapidly evolving, so exact product versions are not important. True or False
False. Cassandra and MongoDB are reasonably well-supported, but for others allocate more time to configure monitoring and likely also for dashboard creation.
98
NoSQL databases are not OOTB: True or False
False. the ones you'd expect, based on popularity – Cassandra and MongoDB, for example, ARE supported OOTB.
But also True: general rule of thumb is to expect NoSQL databases to not have OOTB support, but always check for the latest at the Java supported environments doc page.
99
How do I get the bind variables to show in queries?
capture-raw-sql node property
100
I'm using a just-released JDBC driver for MySQL. Will you work with my driver?
yes, but we'd likely have to set one or all of these properties in app-agent-config.xml:
jdbc-statements
jdbc-connections
jdbc-prepared-statements
jdbc-callable-statements
101
I'm using a just-released JDBC driver for MySQL. Will you work with my driver?
yes, but we'd likely have to set one or all of these properties in app-agent-config.xml:
jdbc-statements
jdbc-connections
jdbc-prepared-statements
jdbc-callable-statements
102
debug-interceptors
a node property. The value is a fully-qualified class name, followed by a forward slash, followed by a method name. Example:
com.appdynamics.MyClass/foo
Inner and anonymous inner class names may be used. The special name can be used to put a debug-interceptor on a constructor method, and can be used to put a debug-interceptor on a static initializer block.
To specify multiple classes, use a comma-separated list.
103
When do you use debug-interceptors
When you are confident a method is being called, but you do not see it in any snapshot call graphs. This often happens when searching for a suitable BT entrypoint, although find-entry-points is more commonly used in that scenario. An advanced use case happens when looking for suitable places to apply correlation configuration.
104
How can you find the call chain of a method that does not appear in snapshots?
set the node property debug-interceptors on the class and method
105
How do you show the syntax for simultaneously setting debug-interceptors on com.foobar.MyClass, method get() and also on the constructor of com.foobar.MyOtherClass
com.foobar.MyClass/get,com.foobar.MyOtherClass/
106
How do you show the syntax for simultaneously setting debug-interceptors on com.foobar.MyClass, method get() and also on the constructor of com.foobar.MyOtherClass
com.foobar.MyClass/get,com.foobar.MyOtherClass/
107
Decompiling
done using third-party tools. The most popular GUI-based tool is called JD-GUI and there are several download sites for this on the internet.
BE VERY CAREFUL in using this! Customers can be quite adamant that we are not allowed to decompile any of their code. Other vendors do all they can to prevent decompiling. Never use decompiling for nefarious purposes, only use it to solve customer problems!
That said, it is not too uncommon for a customer to grant requests for a JAR file from their app, with their full knowledge that we will decompile their code. Experience says that they typically do this because we have gained their trust that we will only do the right thing with their precious intellectual property and help solve performance problems. DO NOT BE THE PERSON TO BREAK THIS TRUST! You will hurt all of our abilities to help customers. On the other hand, when used properly you have established some strong technical trust between yourself and the customer.
108
Spring
Spring may be used to mean an alternative to EJBs (Spring Beans) or any combination of the Spring projects.
One of the goals of Spring was to enable enterprise Java development without the need for (large, some would say bloated) J2EE-compliant application servers. Spring's ability to be deployed on a simple servlet container like Tomcat it the Spring variant of Tomcat called tcServer ("Tomcat server") made it gain popularity fast in the early/mid 2000's. Since then Spring has been eclipsed (no Java pun intended) by more modern frameworks such as Play.
The term "Spring bean" is typically used to describe an alternative to an EJB. However, sometimes the umbrella term "Spring" or "Spring framework" is used in that way, so it is important to get a concise understanding of what the customer is describing.
The list of Spring projects is maintained at the Spring website.
Finally, just to make life more complicated, "Spring Bean" in AppDynamics is actually used more broadly than it should be. In AppDynamics call graphs lots of lines of code are labelled "Spring Bean" even if no Spring code is used in the application. This is one of several instances of AppDynamics over- generalising some specific Java ecosystem terms (other examples happen in servlets and in JMS).
109
Can application use both Spring Beans and EJBs?
Yes (but it is unlikely you'd actually see an application like that)
110
What is an example of Spring support in a demo?
The easiest way to do this is to show Spring Bean transaction detection
111
Does AppD support the Spring framework?
es! However, no credit will be given unless you get this question clarified. Which specific Spring projects?
112
ESB
Enterprise Service Bus is a broad term describing any of several approaches to a component-based architecture. All ESBs have two key constructs:
Components: also called Jobs or Tasks, these are small units of work that are chained together in a sequence by Routes
Routes: also called Connectors, these describe how one Component interacts with others, and can implement flow logic like conditional paths or while loops
113
ESB Implementations
Apache Camel
Apache ServiceMix / Fuse ESB / JBoss Fuse (all basically the same thing)
Mule ESB – One of the more commonly-seen ESB platforms as of 2016
Tibco BusinessWorks
Other frameworks that support ESB-like semantics, but aren't really ESBs:
Netty: while Netty is mostly targeted as an asynchronous web framework, it's logical organisation into Handlers and Channels closely parallels the ESB paradigm of Components and Routes
Apache NiFi: NiFi uses a graph representation, where the nodes are basically Components and the edges (arcs, relationships, whatever you want to call them) are basically Routes
114
find-entry-points
a node property. The value is a boolean value, true or false. Setting the value to true causes verbose find-entry-points logging to be output until the value is switched to false, so it is unwise to leave this property value set to true.
The output of find-entry-points is a thread call stack each time an exit point or detected thread handoff happens, when there is no current BT context. The idea is that somewhere in these stacks are candidates to instrument as BTs.
The output of find-entry-points appears in the BT log. The BT log mixes the output of find-entry-points with the "normal" BT discovery logging, but you can distinguish between the two types of call stacks based on the text after the INFO log level keyword.
115
When do you use find-entry-points?
When you are looking for suitable BT candidates. As of version 4.2 the product has some good UI-based transaction discovery capabilities (more coming in 4.3!), which have removed much of the need for find-entry-points; however find-entry-points can be more useful if the search for BT entrypoints is helped by Unix command-line tools such as grep.
116
In a BT log how can you distinguish find-entry-points output from regular BT logging output?
"Discovery stack" vs. "Logging request stack".
117
How do you set node properties?
Tiers & Nodes → (specific node) → Configure.
NOTE: this is almost never shown in real customer demos.
118
Serial collector
Java 1.0 had a single garbage collector, the Serial collector. The Serial collector is almost never used anymore.
119
Parallel collector
incremental garbage collector improvement on the Serial collector. The Parallel collector is still commonly used because even in Java 8 it is the default collector.
The parallel collector can be specified for only young space ("UseParNewGC"), only old space ("UseParallelOldGC") or both (default, or "UseParallelGC")
120
Concurrent Mark and Sweep collector (CMS
collector of choice among those who have done garbage collection tuning work for many years and is still very commonly seen in the wild.
The CMS collector uses a mark-and-sweep algorithm, and has a "remark phase" – more info in this Stackoverflow article and in this docs page from Oracle.
121
Garbage First (G1)
The most modern collector was the Garbage First (G1) collector. This first appeared in Java 7 but was not considered production quality for quite a while afterward.
122
generational collectors
Java garbage collectors are called generational collectors because they divide memory chunks into generations and operate differently on each generation.
In heap memory there are two generations:
the Young Generation, which can be further divided into memory pools:
Eden space, where newly-created objects are created
Survivor space, where objects that have survived one GC cycle. There may be more than one survivor spaces.
the Old Generation, which has objects that have been around a while. The only memory pool in the Old Generation is
Tenured space – these objects have survived multiple garbage collection cycles
123
non-heap memory
Non-heap memory is where meta-information is stored, and the biggest component of that meta-information is Class objects – not instance objects that an application creates, but the result of calling getClass() on an instance object.
124
PermGen
"Permanent Generation" was the implementation up through Java 6. In Java 7 the move to Metaspace started, and in Java 8 Metaspace is fully used. PermGen size does not change once the JVM is started; this is the root cause behind the dreaded "OutOfMemoryError: PermGen space" error that will crash a JVM.
125
Metaspace
The replacement for PermGen. The main advantage to Metaspace is that it will dynamically re-size itself as needed, so you will never see the dreaded "OutOfMemoryError: PermGen space" error again! The downside is that if you truly have a leak of meta-information like Class definitions, Metaspace will re-size until you have a process crash. The symptom is very much like running out of swap space on a Unix-type machine. This is no coincidence since Metaspace is in many ways very similar to swap.
126
minor collection
happens when the JVM cannot allocate space for a new object. If you have read carefully above, you would recognize this as meaning "Eden space is full." Thus a minor GC may either remove objects from Eden space (because they are no longer referenced) or move them to Survivor space (because they are still referenced).
127
major collection
scans all memory pools for objects to remove (i.e. are no longer referenced).
By default AppDynamics will show when the major collections occur in the Memory tab of a Node page. This is important because major collections cause stop-the-world pauses, which likely can be detected as instances where poor performance is seen.
128
-XX:+
The selection of which garbage collector to use, and for which generation, is enabled by using command-line arguments that begin with -XX:+ and then an option name.
To disable the same option the command-line argument would begin with -XX:-.
129
My application uses a 4 GB heap. Which garbage collector is likely best?
Garbage First (G1)
130
Where can I see, in the demo, when garbage collection is happening?
on the Memory tab in a Node page
131
Your customer used to have constant problems hitting the dreaded "OutOfMemoryError: PermGen space" problem, but now claims that they have "fixed" the problem by moving to Java 8. From that information, you conclude you should put a health rule on what?
Metaspace usage.
132
EJB classes are commonly seen in War files. True of False
False. EJBs are part of the full J2EE specification and are typically found in Ear files, not War files.
133
Your customer is using a standard J2EE application server. Before AppDynamics gets configured or starts up, and assuming the customer allows you to see files on the filesystem, how can you know in advance what business transactions you should expect to see?
Look at the web.xml deployment descriptors in the app server directories.
134
Would you expect to find the interface for a JMS message in a J2SE environment?
No
135
Would you expect to find the interface for a JMS message in a J2EE environment?
Yes
136
AppDynamics can automatically discover EJB methods as business transactions. In which Java environment is this most likely to be useful (J2SE or J2EE)?
J2EE
137
It is possible to use JMS messaging in a J2SE environment, with no app server or servlet container. What must be configured in the environment to do this?
The code for the JMS functionality must somehow be provided to the environment. Specifically, the classpath or OSGi environment must be configured to know where to find implementation classes for JMS, as well as the base interface specifications for JMS.
138
Clojure
A JVM language, with distinct syntaxes that compile down to Java bytecode. Pronounced "closure". A somewhat obscure lisp-like language that runs on the JVM
139
Gosu
A JVM language, with distinct syntaxes that compile down to Java bytecode. Used by Guidewire, a company that makes software for insurance industries
140
Grails
A JVM language, a rapid-development web framework for Groovy and Java
141
How many of these languages can AppDynamics monitor?
```
Java
Scala
Groovy
Clojure
Gosu
Erlang
```
5 (all but Erlang)
142
My app uses Play framework, not servlets. Will my Play BTs be discovered automatically?
Yes
143
Can you instrument Guidewire?
Guidewire is an application, the language it uses is Gosu. We have had success instrumenting Guidewire, but since changes to the underlying Gosu language are not published regularly we don't know what custom configuration (if any) might be needed for your particular app.
144
Kotlin
A JVM language, popular with Android developers
145
Java versions, compatiability
NO Java version earlier than Java 5 is supported. In practice, this is an extremely rare issue since Java 5 and earlier is discontinued and unsupported – although they CAN still be downloaded today.
146
What is the possible vendor issue with JRockit 5 and 6?
There is a longstanding Java "gotcha" (some would say a bug) related to class loading that can occasionally cause app startup to freeze when there is a Java agent running (as is the case with AppDynamics). The freeze is immediate, the program will not run at all. Technically any Java version can exhibit this behavior, but in practice it is more common with JRockit 5 and 6. There is nothing you can do to fix this, typically killing the frozen process and re-starting will allow the program to run. Once the program starts up normally the problem will not happen. You are likely to never see this issue as of 2016, but if you do, know the playbook: kill the process and re-start.
147
What is the possible vendor issue with IBM?
IBM Java releases have historically had a noticeable performance penalty when the ability to dynamically re-transform classes is enabled. It is not clear if that issue has been addressed in current IBM Java releases, engineering still needs to benchmark that against several releases. In order to avoid this scenario, the agent packaged for IBM JVMs has that capability shut off. This is done in the AppDynamics agent, not in IBM's JDK/JRE. Using the non-IBM agent ("Sun and JRockit JVM agent") works fine on IBM JVMs, but there may be the aforementioned performance penalty (IOW, it's okay in pre-prod, beware in production).
- The requirement to restart can have a significant impact on the time required for a POV. Every operation that does new BCI will not take effect until a restart is done, this can include:
* Custom entry/exit points
* MIDCs
* Info Points
* Changes to fork-config
- When running on IBM WebSphere, you are required to use the Java version bundled with WebSphere. This is due to some security manager configuration IBM does, and that configuration puts an additional requirement on agent installation, documented in the docs page for installing on WebSphere.
148
What is a possible Java 6 version issue?
There is a very nasty bug in Java 6 that was fixed in Java 7, specifically in jdk1.7.0_17b06. It affects agents with Hotspot snapshot capability, so basically all agents we would be likely to deploy in any new environment. Because of this, avoid installing any 4.x agent on a Java 6 environment. If the customer absolutely positively won't upgrade their JDK, then there are some safey precautions that can be taken to avoid the deadlock outlined in the bug report, but even then expect overhead to be higher than normal. The specific configuration should come from support. The messaging to the customer is: you are using a version of Java that is known to be broken, causing deadlocks. Your app is at risk if you don't update.
149
What is a possible Java 5 version issue?
Java 5 has slightly reduced capabilities for re-transformation. In practice, you will likely never encounter this situation because of the rarity of Java 5 and because of the rarity of hitting the use case.
150
What are the two primary ways to diagnose memory leaks in AppD?
Memory UI and the Metric Browser.
Typically the Memory UI is used initially, until there is enough confidence in any health rules set up. Once good health rules are in place then alerts and dashboards – i.e. things powered by the metric browser – are used.
151
Leak
Any occurrence of memory not being reclaimed, so that memory usage is increasing.
152
Leak detection
Detection of one specific common root cause of a leak: when objects are put into Java Collections and never released. This is the type of leak detected by ALD.
153
Instance Tracking
Counting of the number of live objects belonging to a specific class.
154
Automatic Leak Detection (ALD)
One of two powerful tools used to detect memory issues.
Located in the Memory tab
ALD will only detect objects put into Java Collections that are no longer used. That is by far the most common leak use case, but there are others. OIT can be used to simply count objects – this may detect leaks that do not fit the ALD use case, such as when the leaked memory is part of an object instance attribute data but not in a java.util.Collection.
155
Object Instance Tracking (OIT)
One of two powerful tools used to detect memory issues.
Located in the Memory tab
OIT can be used to simply count objects – this may detect leaks that do not fit the ALD use case, such as when the leaked memory is part of an object instance attribute data but not in a java.util.Collection.
156
A Java class that has a leak whereby objects are held in array objects can be detected by
OIT (and NOT ALD!)
157
What library MUST be present in order to use Object Instance Tracking?
tools.jar, which is included in the JDK bundle but not in the JRE bundle.
158
In a demo, where do you go to show how to enable ALD?
Use the memory UI
159
JMS
```
Stands for Java Messaging Service.
Standard from the early days of Java. Very well supported OOTB in AppDynamics.
Implementations:
ActiveMQ
SonicMQ
WebSphereMQ
```
160
AMQP
Stands for Advanced Message Queuing Protocol
It is NOT JMS!
Next-gen protocol that fits better with asynchronous logic flow. Some autodiscovery issues in AppDynamics, support is improving in the 4.x releases.
Implementations:
RabbitMQ dominates the field
161
"Can we correlate through XXX messaging system?"
JMS: yes
AMQP: yes
Transport is HTTP: yes (occasionally not OOTB)
Others: maybe using custom correlation, no OOTB
Look at the messaging object APIs. If there is any construct and API that sounds like "properties" or "headers" then your chances are pretty good. On the other hand, if the APIs sound more like "readInt" "readString", "writeBytes" etc. then the answer is probably no. However, some systems implement an "envelope" object that wraps the message in transport. Sometimes the envelope object enables correlation because that object allows property tags.
Most messaging systems have some sort of ID in the messages, so when full correlation is impossible the fallback is to use Analytics to enable tracking message segments together.
162
print-class-info
a node property. The value is a fully-qualified class name. Inner and anonymous inner class names may be used by using the same "$" notation you would see if you invoked getClass().getName(). To specify multiple classes, use a comma-separated list.
The output of print-class-info appears in the agent log regardless of the log level in effect.
163
When to use print-class-info?
When you need to see the rough equivalent of Javadoc information for a class – the method names and all argument and return value types. This comes up when doing:
- Correlation configuration
- BT splitting
- Backend splitting
- MIDCs
- Information points
164
A customer is impressed by your description of realtime business metrics, and wants to configure some in their application. The customer tells you that a value of interest is part of a specific POJO-based business transaction, but has no specifics and cannot show you source code. What can you do in AppDynamics to find more information needed to configure the info point?
set the node property print-class-info on the class used for BT detection.
(Similar questions can be formed for MIDCs, etc.)
165
Reactive programming
programming style that is gaining in popularity in the Java world because a well-formed reactive application generally performs better than non-reactive applications. Reactive programming is not a part of the core JDK, but is enabled in certain Java third-party packages. Outside of Java, the basic programming style for Node.js is reactive: an event loop runs on a single thread and calls small callback-style methods that have very specific tasks and are expected to execute quickly without blocking. The Erlang language is another example of an environment where reactive programming is prominent.
In Java, the following third-party frameworks work well with reactive programming:
- Akka (frequently used together with the Play web framework)
- Spray (web framework)
- Vert.x (web and messaging framework)
- Netty
- RxJava/RxNetty
166
Does AppDynamics support Akka?
Yes
167
Thread Profiler Dynamic Service
mainly used when an AppDynamics agent is used in an application with some asynchronous behaviour that we don't support OOTB
A typical timeline of how the need to use the Thread Profiler Dynamic Service is discovered may look like:
- Agents are installed, instrumentation doesn't look right because of any or all of:
* missing BTs
* missing backend calls
* suspiciously short BT response times
- Suspicion grows that an async framework is being used because of any or all of
* conversations with the customer
* examination of BT logs
* "hint" method name keywords in BT logs or call graphs
168
You realise that you may need to use the thread profiler service at a customer visit later in the week. What do you need to do to prepare?
validate the exact agent version; check for a matching build on the threadprofiler wiki site; request a build for your agent if there is not one already
169
Name basic HTTP functionality web frameworks
```
Servlets
Play Framework
Vert.x
Netty*
Apple WebObjects
```
(*Netty is a special case because it is both a web framework on its own and it is also a building block used by other web frameworks like Vert.x and Play)
170
Name OOTB web frameworks supported
Java Servlets
Play Framework
Apple WebObjects
171
Name webs service implementations
JAX-WS
JAX-RS (for RESTful web services)
Apache CXF
172
node property
a specific setting in the AppDynamics controller. As the name suggests, it is a property (key/value pair) whose scope is a node in AppDynamics. For Java APM, a node maps 1:1 with a JVM instance.
173
How are node properties set?
set using the Configure button on the Agents UI.
174
What node property can be used to understand the API structure of a Java class?
print-class-info
175
Name three broad categories of runtimes are commonly seen in Java?
* J2EE-compliant application servers: e.g. Weblogic, WebSphere, Glassfish, JBoss
* Servlet containers: e.g. Tomcat, Jetty
* Other
(The "other" category is itself quite broad, but the one common thread is that the appservers and servlet containers use synchronous HTTP, whereas the "other" category is almost exclusively asynchronous HTTP. Examples include:
```
Play
Spray
Vert.x
Netty
RxJava)
```
176
A customer uses a brand-new open-source asynchronous HTTP framework you have never heard of. Should you expect OOTB BT detection?
No. That doesn't mean it won't happen, but expect that you will have to do some configuration
177
You find out in a TDD that your customer is using a brand-new open-source asynchronous HTTP framework you have never heard of. What should you do before starting a POV?
You find out in a TDD that your customer is using a brand-new open-source asynchronous HTTP framework you have never heard of. What should you do before starting a POV?
178
BCI
```
bytecode injection (
Bytecode injection is modifying Foo. class at runtime to inject code into it right before its loaded and run.)
```
179
JMX
Java Management Extensions (JMX) is a Java technology that supplies tools for managing and monitoring applications, system objects, devices (such as printers) and service-oriented networks.
MX is an incredibly useful and important topic in Java AND a competitive differentiation for us. Why? Because nobody else has a JMX console allowing you to search for JMX metrics in the running JVM and then view those Metrics IN REAL TIME!
The important thing to be aware of here is that we don't track EVERY JMX metric out of the box, we have access to every metric but we don't keep a historical record or baseline every JMX metric. There can literally be 100,000+ Metrics to track in some application servers so it quickly becomes evident why we don't track them all.
If you have a JMX metric you want to track you have to configure AppDynamics to do that, either by searching for the metric in the JMX Console or by creating a link to the JMX metric you need directly in the Configuration pane.
180
Agent
Code that collects and reports data.
Agents can refer to languages (Java, Node.js, Python, etc), machines (hardware and network data), and databases, etc.
181
Transaction snapshot
A collection of detailed diagnostic information captured during a single invocation of a business transaction.
Examples include call graphs and timing during a single user login, where login is the business transaction.
182
What are the elements (as of 4.3) of app-agent-config.xml?
configuration-properties
sensitive-data-filters
agent-services
service-configuration-properties
183
What is configuration properties?
Found in app-agent-config.xml
This section is rarely edited by Sales Engineering. It contains some properties that affect agent behavior. Disabling the agent is almost never done in this file because it is easier to do from the UI agent page (but read the comment for a good description of what disabling the agent is – in particular, disabling the agent does NOT remove existing bytecode modifications!). The agent-overwrite property controls how conflicts in the values of some properties (see below in the TransactionMonitoringService section) are handled.
184
Sensitive Data Filters
Found in app-agent-config.xml
In rare cases these are extremely important, like when a customer environment has passwords in system properties (a bad practice, but it happens). You should be able to figure out the general usage model by reading through this section.
185
Agent Services
Found in app-agent-config.xml
Most of the content in app-agent-config.xml is in the agent-services element. These are internal agent services that have configurable behavior, and are important to know. Note that each service element has a name and an "enabled" attribute – IOW, to disable any of these internal services, change the value of "enabled" to false.
186
Service Configuration Properties
Found in app-agent-config.xml
187
DynamicServiceManager
Part of Agent Services, found in app-agent-config.xml
The agent has the ability to ingest a drop-in service, which activates by dropping a known jar file into a folder under the external-services directory, and de-activates by moving the service jar out of that directory. The Thread Profiler Dynamic Service is an example of such a service.
188
InstrumentationSdkPluginManager
Part of Agent Services, found in app-agent-config.xml
This service is enables the agent iSDK, a topic that will be covered in Level 2.
189
BCIEngine
Part of Agent Services, found in app-agent-config.xml
This is the heart of AppDynamics bytecode instrumentation. Note that because there is an "enabled" flag, it is possible to start up a Java process with the -javaagent flag, and not do any BCI. Try to figure out the meaning of the elements in this service, especially anything related to excludes.
190
SnapshotService
Part of Agent Services, found in app-agent-config.xml
Some properties controlling snapshot functionality. Sharp-eyed readers will notice that there is a property name that also exists in the service-configuration-properties section. That is probably a mistake.
191
TransactionMonitoringService
Part of Agent Services, found in app-agent-config.xml
This is the most-commonly edited section:
- First, all of the properties in this section are basically the same as node properties– IOW, you can edit them in app-agent-config.xml instead of using the Node UI. Typically it is easier to use the Node UI, so editing in app-agent-config.xml is not commonly done for this purpose. Some of the properties in this section are hot properties, meaning you do not have to restart the JVM when you change them when using the Sun/Oracle agent (if you don't understand why the agent is important, read JVM Platforms and Versions).
- By far the most commonly-edited section is fork-config. This controls how AppDynamics tracks multithread business transactions.
• job elements define the classes to be instrumented. The methods instrumented will be the constructor and the method in the filter-value attribute of the method-name element.
• exclude and excludes elements are exceptions to the job configuration, to avoid over-instrumentation.
• include elements are exceptions to any excluding, so you can exclude a package structure but then create an include exception for a specific class.
- At some point almost every sales engineer ends up modifying a part of this section
- This section is hot config: no restart is necessary when using the Sun/Oracle agent.
192
JMXService
Part of Agent Services, found in app-agent-config.xml
This section does some fine tuning of JMX collection, including configuring the collection interval. One thing you cannot do in this section is change which JMX attributes are registered as metrics
193
Can I change the configuration of the JMX collection interval in controller-info.xml?
No, that configuration is in app-agent-config.xml
194
Can I limit the JMX metrics gathered?
Yes, by default (i.e. OOTB) only a small number of JMX metrics are gathered, you must explicitly configure others to show up in the metric tree (and thus to be used in health rules).
195
JMX-only monitoring
this is sometimes useful as an alternative to using a machine agent extension to gather infrastructure metrics from a Java system like Cassandra or one of the Apache big-data environments (Hadoop, Spark, etc.).
196
What is the difference in the default BT timing between 4.4 and 4.5?
4.5 surfaces asynchronous calls and allows to drill down into the timing of all the various activities that are happening in your application.
The Waterfall View within the snapshot viewer has been comprehensively enhanced. It now shows time spent in uninstrumented backend systems as well as inactive threads within instrumented nodes, and also shows the relationships between the segments. For asynchronous Business Transactions, it also labels the threads where the Business Transaction begins and ends.
197
Is it possible to attach the Java agent to a running JVM Process?
Yes and can be incredibly useful if you need to get instrumentation up and running without restarting any processes. This is a unique differentiation for AppDynamics against many competitors.
Attaching the agent to a running JVM allows you to install the Java Agent without requiring a JVM restart. This approach would normally be used alongside adding the ‑javaagent argument to the JVM startup script, or some other persistent approach to ensure that the agent is loaded again at the next JVM restart.
198
You are in a competitive POV with a QA group that involves all three of the big APM competitors. Which competitor should you be most concerned with?
Dynatrace
199
Dynatrace says they capture PurePaths for 100% of the user transactions, and you're saying you only capture some snapshots. Why shouldn't I go with Dynatrace, since they give me all of the information and you don't?
Dynatrace does not give "all of the information." They manage the overhead of gathering all PurePaths by reducing the visibility of the code in each PurePath, so that when load increases you see less and less information in each and every PurePath. AppDynamics always gives you full call graph resolution in the Snapshots we collect, because we are the only APM vendor that will intelligently gather the Snapshots you need to see.
200
What is the main requirement that would rule out New Relic?
If SaaS is not an option, then New Relic is not an option.
201
If a customer looking at an on-premises comments that they have OpEx budget, but not CapEx, is that good or bad for us?
Good vs. Dynatrace, because they require more hardware for on-premises deployments.
202
What is AppD's benefit to dynamic OOTB thresholds?
Quick time to value. AppDynamics transaction scoring flags poor performance without any threshold configuration.
203
What is AppD's benefit to visibility into framework AND custom code?
this is mostly directed at New Relic and CA. In New Relic it is necessary to do a "thread profiling session" to gain visibility into custom code. In AppDynamics no such extra step is necessary. The New Relic way is the equivalent of closing the barn door after the horse has escaped. If you know you have to do a thread profiling session, you probably learned it by not seeing the code you wanted to the first time you looked – so you missed the problem the first time you looked. It is also necessary in CA Introscope and New Relic to maintain configuration of custom code to monitor, which adds to cost of ownership.
204
What is "no change in visibility due to change in application load" important?
Critical monitoring data is at full granularity at the time you need it most.
In Dynatrace, the granularity of call graph information gets coarser as application load increases (DT calls this the "overhead limiter"). If you are not familiar with this, go back to the compintel info we have for DT. DT's overhead limiter is called out in their documentation quite clearly. The related differentiator here is our low and consistent overhead (i.e. our overhead does not increase as app load increases).
205
What is the unity of licensing?
JVM
Servers are not licensed, so if a customer runs 8 JVMs on a single OS instance, the licensing is the same as it would be if the customer runs 8 JVMs on 8 OS instances.
206
The AppDynamics agent installation must be in a filesystem space that is writeable by all process owners for monitored applications. True or False
True. This is because the agent will want to create log and other directories in the agent installation filesystem.
207
A single agent installation cannot be used by multiple JVMs, either in a single logical application or even in multiple logical applications. True or False
False. It is possible for a single agent installation to be used by JVMs in applications reporting to different controllers, because all of the controller-info.xml information can alternatively be specified using environment variables or "-D" parameters. See the comments in any Java agent controller-info.xml file for how to do this.
208
The Java bits for the IBM agent version and the Sun JVM version are the same. True or False
True. The only difference is in the Manifest file of the javaagent.jar. Thus, you can use the IBM agent on a Sun JVM (dynamic re-transformation will not work because it is disabled in the Manifest), and you can use the Sun agent on an IBM platform (there may be a noticeable performance penalty). Also, the "Sun" agent is the agent for any non-IBM platform: JRockit, OpenJDK, and Sun.
209
Most of the AppDynamics code in the agent is obfuscated, so that the code is difficult to read when decompiled or when it appears in stack traces. True or False
True. In tools.appdynamics.com support maintains a log file reader which has unobfuscation capability when needed.
210
There is no support for supporting a hierarchy of configuration for agents. True or False
False. Configuration can be override-able per agent version. This is enabled by the support for the "verXXXX" directories within the agent installation. In practice, this is rarely used and the common convention is to only do the configuration in the "conf/" directories under the "verXXXX" directory for the agent installation, but the intent is to support multiple versions of the agent from within the same file structure.
211
True or false: on Unix systems the Java agent must be installed in /opt/appdynamics
False, there is nothing that requires the Java agent bundle to be installed in any specific location
212
True or false: Using a Sun agent, changes to are picked up without requiring a restart.
True
213
Exit Call
Given the right support the Java agent can see database queries being ran against the database AND which database it is connecting to, this is shown on the flow map as an 'exit call' or backend.
214
What is the BT limit of an agent?
The default out of the box limit for the number of business transactions an AGENT can detect is 50. If there are more unique transactions than this it will be recorded under "All Other Traffic".
215
What is the BT limit for an application?
The controller has a limit of 200 business transactions per application but this is for every agent sending data in.
216
MIDC
Method Invocation Data Collector. A MIDC will collect specific bits of data e.g. a username and is therefore useless for using in health rules but very useful for querying / searching for data in transaction snapshots.
217
Information Point
An Information Point collects metric based data and applies aggregations on that data (AVG, SUM etc), this is very useful in health rules and alerting.
218
Normal/Slow/Very Slow Tags
The Java Agent tracks performance issues based on a 'moving average' and NOT the baseline. It's important to understand this difference because the Java Agent will take snapshots and classify transactions (SLOW/VERY SLOW/NORMAL) based on the moving average.
The baseline is calculated on the Controller side using the following technique https://docs.appdynamics.com/display/PRO45/Dynamic+Baselines .
The Java Agent never sees the baseline.
219
JDBC
Java Database Connectivity is an application programming interface for the programming language Java, which defines how a client may access a database. It is a Java-based data access technology used for Java database connectivity. It is part of the Java Standard Edition (J2SE) platform, from Oracle Corporation
220
Assuming the customer agrees that instrumenting the production (legacy), QA (next-generation) ad Performance (next-generation) env is aa good approach, how would you advice the customer to deploy?
Legacy QA > Legacy Performance > Legacy Production > Next Gen QA > Next Gen Performance
221
What is the configuration needed for an asynchronous env in order to measure times that are as useful as Average Response Time in a synchronous environment?
Asynchronous Demarcation Point
222
You have not yet discovered what async HTTP framework is being used. At this point, you should expect to see auto-detected BTs on the next-gen env that uses this framework. True or False
False
223
Given that you know the legacy production env uses Java servlets, you would expect to see auto-detected BTs on the legacy production env. True or False
True
224
Which BT metric can be used to find the root cause of the problem?
Average Response Time
225
What is Blocking?
Suspension of code execution that happens when a thread of execution needs to acquire a semaphore, but cannot because other threads are doing the same thing
