Dynatrace Reviews

To discover the root cause of problems and improve our applications or environments based on very specific and detailed informations that AppMon brings to us.

Developers have started to consult us (the Application Support Team) more than before AppMon had been implemented.

PurePath lets us see the steps of a transaction and the time of each one, then we can know exactly what happened in what time.

I would like to know if classes and methods selected in "Method Sensor Rules" were changed in applications, and not depend on the developers to warn us. Today, if the name of a class or method that I previously selected in "Method Sensor Rules" or in "Sensors" were changed, I am not aware of this. I will not know until I need some information on Dynatrace AppMon. Maybe just a warning if a specific method or class in "Method Sensor Rules" does not exist anymore in the application is enough.

We use it for synthetic monitoring to ensure our applications are available and performing as expected across multiple ISPs and geographical locations. We also use this tool to report out performance metrics on a daily basis to a larger audience to help senior leadership get a better idea around how things are performing.

It has enabled us to have a deeper insight into our application availability and performance. Depending on the application, we have a lot of both internal and external components that are loading, and in most cases, we will detect our own internal but it is extremely hard (without an outside perspective) to detect these third-party issues. Dynatrace's synthetics has allowed us to pinpoint these problems and make improvements on how we can gracefully handle these types of issues without customer disruption.

The alerting has been a key component for us. Not having to be constantly eyes on glass has been a huge life saver for us. The API has also been another key area as we have an automated performance report that goes out every day and getting the necessary metrics has been a breeze. Also, since Dynatrace's acquisition of Keynote, they have done a fantastic job of combining the two into a single service platform.

Everything is great, but the licensing could always be cheaper. With the every growing tool set of Ops teams, we find it harder to budget for tooling while ensuring we still have the proper insight into our applications. 

Catchpoint.

We use Dynatrace to monitor our webservers. 

Dynatrace has given us one simple dashboard to monitor all of our servers and web applications. If we have an application error, it is really easy to find the specific web request in Dynatrace and debug what went wrong.

I find the "PUREtrace" functionality the most valuable. It lets me drill down into the specific web request and see exactly what processes were called, what database calls were made, and if the application made an error. It also shows me the error message. 

It gives me an overview over how long each process call took, enabling me to find bottlenecks in the application.

I would like to see Redis calls being included in the "PUREtrace" functionality. It would be great to see the different Redis calls and find bottlenecks.

We replaced New Relic with Dynatrace. We were quite happy with the easy installation process and how quickly we received a good overview over all of our web applications.

To monitor and mimic the external customer experience for our external customer-facing websites. This tool does the exact same thing. It monitors the customer experience at over 10 US locations and informs us if there are any issues through email alerting and text alerting in the mobile. This has made our life so much better.

This is the first gate where we come to know if our external customers are facing any slowness in response times for critical page navigation irrespective of if there is any background issue or not. Once there is any slowness, an alert is triggered to the corresponding team and they immediately start looking into the background to find out any issue. This way, when a customer reports any issue, we can always assure them that we are already working on the issue and it will be resolved soon.

There are lot of features, but I found data analytics and triggering are the two most valuable feature of this tool. 

• Data analytics help us to find us issues in the short-term or long-term. 
• Triggering gives us warning that system is getting slow and we need to nail down the issue soon, so it does not impact our business.

This tool had a feature of doing load test in production or lower environment, which was shut down earlier this year. We are missing that feature badly and we definitely want to see that feature back. 

Our development group has started using Dynatrace extensively. It helps them find bottlenecks caused by code.

The topology map is extremely useful. The dashboarding capabilities are unmatched. From a management perspective, I have a single pane of glass view to my entire environment.

Possibly include some network monitoring capabilities. I honestly feel the product already has everything we would need.

We were using New Relic, but we never got the full picture of our production environment. Their pricing model was an issue, too. We were unable to put all our servers on their tool due to the high cost. So, we were limited in what we could do. Their dashboard was almost non-existent. It would require us to build our own which we did not want to do. Installation complexity and maintenance were also an issue. 

Dynatrace claimed to be super simple, and we thought let us try it. Honestly, we were amazed by how simple it really is. The other motivation was the design of the product itself. Everybody can show charts and metrics, but Dynatrace’s infographics are amazing. The dashboarding is simply best in class.

I use DT for identifying performance bottlenecks on the DB, mid-tier and front-end, which is built on .Net platform.

The performance testing is executed using the LR tool, where the DT headers are added. Once the test is completed with the filter criteria in dashboard, we are able to segregate the transactions having slow response time and root cause.

For one of the trading applications, we were able to identify the slow performance query which was resulting in overall performance degradation of the GUI. The Query involved multiple joins and clause which when executed by multiple users slowed the overall DB response time. From the DB Chart in DT and DB Dashboard, we were able to arrange the Query within the SP against slow response time/execution time. Analysis resulted in optimizing the query resulting in improved performance.

The dashboard customization based on the performance metric requirement is one of the most exciting features in DT. I am able to customize my dashboard based on the test requirement and it helps me to focus on the area that really needs close monitoring.

I would suggest to have more rich client features on Appmon as soon as possible. I agree most of the things can be done using Appmon, but users (like us) are bit hesitant to use Appmon compared to the Client.

Appmon:

• Drill downs to root causes.
• Easy to find the performance bottlenecks.
• Full insight into all classes.
• UEM helps to identify user experience and detailed steps performed by the user.

I have identified and fixed the following performance issues in non-production before we release the app:

• Identified memory leaks that caused heap utilization maxed out.
• Identified thread bottlenecks at JVM.
• Identified JDBC connection pool limits.

There are so many!

• Transaction flow: Helps to identify server health at every layer.
• Threads on JVM: Helps to identify active, hung, and count.
• GC: Helps to identify GC collection time and number of times GC kicks in.
• UEM: Helps to identify user experience.

DT Saas: Does not have all the features that Appmon has. Maybe in the future releases it may have all features.

Application performance monitoring for testing our pre-production environments. Along with that, we use AppMon to create B/T's for alerting and graphing trends.

Prior to the use of Appmon, our team was in the dark. We had zero visibility into our production application, and it would take up to days to find out why our clients were being impacted and how.

Since Appmon has been leveraged, we are now down to just hours (sometimes minutes) in resolution times.

PurePath analytics, I can't imagine not having this feature in your application. Not only have we been able to improve troubleshooting, but we have also used PurePath data (response times) to improve and tune application performance.

Ease of Use. I find it is very difficult to train someone in using this application. As amazing as it can be, the learning curve is extensive.