Dynatrace Reviews

We're implementing an end-to-end service monitoring solution, using Dynatrace as a key component. Dynatrace is being deployed in multiple key probes through the end-to-end path. A centralized service analysis probe and report server have been deployed as well, to present the data in a friendly way, and the dashboard matrix can be customized for business usage.

The operation team gets a much more efficient tool to monitor the service end to end, 24/7. As soon as the monitoring service shows any performance downgrade, there are many tools inside Dynatrace to help us quickly troubleshoot.

Dynatrace can look into application transactions at the packet level, which pretty much relieves us of the work of manually collecting, analyzing, summarizing, and presenting the data, as we had done in the past. For example, with Dynatrace it's easy to identify the problems from the network layer up to the application layer, which saves us much effort and time.

Dynatrace is also very easy to configure based on our business requirements.

To be honest, the customer support is not quick and helpful at this stage. We are deploying Dynatrace into our network. I've raised a couple of technical questions with the support team but the response was not fast and didn't cover all my questions at all. I have had to ask some questions two or three times yet, to date, I still have not received a good answer for some questions.

Full stack monitoring capabilities. Containerized monitoring is huge for us as majority of our applications are using containers.

It highlights areas that we could be doing better and increases our performance metrics by showing the biggest pain points. The analytics are amazing!

The big data analytics is the most powerful tool at my disposal. With the analytics, I can review behaviors, trending issues, and resolve issues before they impact our clients.  

Some of the APIs and integrations are a bit tougher than others to integrate. Django would be amazing!

• Troubleshoot application slowdowns
• Ability to track down what is happening "under the hood" when a user complains about a bottleneck
• Pinpoint areas of code that are vulnerable to bottlenecks

It has reduced customer complaints. We spend less time on troubleshooting issues since Dynatrace proactively informs us of an impending bottleneck.

Ability to drill down to code level to identify user bottlenecks. This enables the programmers to quickly revamp the code to resolve the issue.

• More Integration with cloud services
• Simplified licensing
• Single pane of glass view
• Simplified reporting
• Integration with ServiceNow and PagerDuty

We use it as an Application Performance Monitoring solution for customer applications we support. For other customers, we implement it on their applications, onsite or in the cloud.

Most important use cases for us:

• Trouble-shooting when something goes wrong - slowness, unavailability of any kind, errors.
• Integration within the CI/CD pipeline helps avoid problems in production by detecting application faults upfront.
• Dashboards for business and management display user satisfaction based on real measures like Visually Complete.

For our own organization, we manage to support a large application with a lot of users with only a few people (DevOps team). The insights we get via Dynatrace make sure that we can act quickly on incidents, or often even prevent them from happening at all. This way, we avoid "war-room" scenarios and focus on the things that matter.

UEM (RUM): User Experience Management (real user monitoring) puts you in the "user's seat" and gives you insight into how they experience the application. Often, this gives a totally different view than just watching the backend calls.

24/7, all transactions: The fact that every transaction is captured gives us the possibility of acting on every exception. But it also shows us what happens when everything works well, so we can compare it with the moment something goes wrong.

UEM/RUM works great for web clients and Android and IOS apps, but for other rich clients it's a lot more challenging.

The new Dynatrace solution lacks test-automation integration inside the CI pipeline. I hope that will arrive soon.

We are using Appmon and Gomez tools to monitor performance metrics in production systems. Appmon is used to monitor performance of production and test environments. We even use it to debug the results of performance tests using Appmon.

We have used Dynatrace for various projects. Everytime it has been really handy in identifying the root of the cause. We have used this tool to help in cases such as production performance outages and functional level issues.

PurePath is the most useful feature in the Appmon tool. It gives a lot of flexibility in identifying issues and finding the flow of execution. PurePath is also used to create many complex measures and business transactions as per our needs.

Addition of more statistical features, plus different time series modeling techniques, would really help for future versions.

• Production application and environment health monitoring tool
• Dashboard to help present the statistics to management

Real time monitoring helps reduce downtime. It also helps to get a detailed trace of each transaction. It saves a lot of time in determining what is the likely cause of an issue that an end user may be experiencing.

Log files for JVM transactions help to debug most of the failures. It helps to detect application dependencies, and provides one consolidated view of application performance.

• Requires application knowledge
• Hard to use for beginners, to setup and explore
• DevOps plugin monitoring tools need improvement

Our first use case for Dynatrace was application analysis to find the source of a performance problem on a critical management application.

Through analysis of transactions and transaction flow, we clearly saw the path taken by our transactions, and identified through drill down and PurePaths the time consumed by each class and method. The bottleneck was identified and the problem corrected.

Dynatrace's power lies in its ability to inspect and chart transactions, and draw the PurePath tree. The parameters of the requests and methods can be selected to access the necessary information for efficient analysis.

Some technical architectures are based on an event mechanism operating via a publish/subscribe system. APM technology sometimes reaches its limits to go upstream. 

It should also be remembered that APM is often useful in production where problems are difficult to reproduce. You must be careful in using Dynatrace so that the overhead is limited.

• Alerts
• Monitors
• Reporting and troubleshooting
• Proactive monitoring
• System health and business process monitoring

The web-based UI needs to be improved. The client seems to be heavy on laptops and desktops. Some reports are only on the client versus the Web UI.