As the complexity of the parallelism in high performance computing continues to increase, traditional tools such as MPI and OpenMP are starting to become inadequate. Within this context, the HPX C++ library emerges as the first implementation of ParalleX, an execution model that describes message-driven and task-centric computing with the use of lightweight threading, futures, global address spaces and other mechanisms, in order to mitigate problems such as starvation, latency, management costs, and resource contention. In terms of monitoring HPX applications, this work includes the study of: i) HPX performance counters, a framework that provides real-time access to a number of performance metrics; and ii) APEX, a tool with an event API that enables runtime auto-tuning of application parameters and the generation of execution profiles, with the aim of finding areas of application. This resulted in an extensive report on the inner workings of these tools, which, due to its importance, was incorporated into the dissertation itself. During the development of this project, a new HPX counter was defined that monitors component variables and exemplifies how the framework of counters can be adapted to handle situations outside of its initial scope. This dissertation’s main contribution is HpxTrace, a tracing tool for HPX applications that was modeled after Dtrace and built with APEX’s policy engine. HpxTrace provides a system of probes that trigger upon the occurrence of certain events. The user can associate actions with each probe to collect and manipulate event data. Events include readings from HPX counters, execution of tasks, message exchanges, and events instrumented in the application by the users themselves. To describe the actions each probe should take, a scripting language was developed using the Spirit library from the Boost library collection. In addition to providing the basic operations and aggregations found in Dtrace, the language had to be adapted to the distributed nature of HPX. This was accomplished by taking measures such as separating variables into local and global contexts and adding synchronization mechanisms. To validate HpxTrace, two implementations of stencil algorithms that solve heat distribution problems were used as case studies. HpxTrace detected the differences in the optimizations between the two versions and their impact on performance. Following testing, it was concluded that HpxTrace can be used to analyse and measure the performance of HPX applications. Additionally, it proved to be particularly useful in comprehending the internal behavior of HPX, which is valuable for tasks like finding performance optimizations, as well as debugging and learning the platform itself.