Evento Framework
  • Introduction
  • Architecture Overview
    • Distributed Systems & Microservices
    • Recative Manifesto & Reactive Principles
    • State-of-the-art Patterns
      • DDD (Domain Driven Design)
      • CQRS (Command Query Responsability Separation)
      • Event Sourcing
      • Messaging
      • Saga
  • GETTING STARTED
    • Quick Start
    • TodoList - RECQ Tutorial
      • Problem Description and Requirement Gathering
      • RECQ Payload Design
      • RECQ Components Design
      • Set up your Development Environment
      • RECQ Payload Evento Implementation
        • Domain Commands
        • Domain Events
        • Views
        • Queries
      • RECQ Components Evento Implementation with Spring Data
        • TodoListAggregate
        • TodoList Model with Spring Data
        • TodoListProjector
        • TodoListProjection
        • TodoList Invoker
      • Expose the RECQ architecture with Spring Web
      • Test Your App
    • Extend TodoList - Handle Complexity Tutorial
      • Unique identifier generation
      • Extends behaviors with Observer and Services
      • Cross Domain Consistency with Sagas
      • Handle Real time data updates with MQTT and Save-Notify Pattern
  • RECQ Patterns
    • RECQ Patterns
    • RECQ System Pattern
      • Component
      • Message Gateway
      • System State Store
    • RECQ Communication Pattern
      • Component to Component
      • Component to System State Store
      • System State Store to Component
    • RECQ Component Pattern
      • Aggregate
      • Projector
      • Projection
      • Service
      • Invoker
      • Saga
      • Observer
  • Evento Framework
    • Evento Framework Introcution
    • Payload and Messages
      • Command
        • Domain Command
        • Service Command
      • Event
        • Domain and Service Event
      • Query and View
    • @Component
      • @Aggregate
        • Aggregate State
        • @AggregateCommandHandler
        • @EventSourcingHandler
      • @Projector
        • Projector @EventHandler
      • @Projection
        • @QueryHandler
      • @Service
        • @CommandHandler
      • @Invoker
      • @Saga
        • SagaState
        • @SagaEventHandler
      • @Observer
    • Dead Event Queues
    • EventoBundle
      • EventoServerMessageBusConfiguration
      • ConsumerStateStore
        • InMemoryConsumerStateStore
        • PostgresConsumerStateStore
        • MysqlConsumerStateStore
      • Context
      • TracingAgend and @Track
        • SentryTracingAgent
      • Autoscaling Protocol
        • ThreadCountAutoscalingProtocol
      • Injector and @Component
  • Evento Server
    • Evento Server Introduction
    • SetUp Evento Server
      • Advanced Options
      • Evento Event Store Modes: APES and CPES
    • Evento Server Cluster
    • Bundle Deploy Script
  • EVENTO GUI
    • Explore RECQ Systems Visually
    • GUI Auth
    • Payload Catalog
    • Component Catalog
    • Bundle Catalog
    • Cluster Status (Experimental)
    • Flows
      • Performance Evaluation
    • Application Graph
    • System State Store
  • Evento CLI
    • Evento CLI Introduction
    • Update Version
    • Publish
Powered by GitBook
On this page
  1. EVENTO GUI
  2. Flows

Performance Evaluation

Optimizing Your Evento Application

PreviousFlowsNextApplication Graph

Last updated 11 months ago

The Evento framework empowers you to not only build distributed applications but also to optimize their performance for efficiency and scalability. The performance evaluation feature, seamlessly integrated with Flows, provides valuable insights into how your application executes. By analyzing execution times, invocation frequencies, and flow structure, Evento helps you identify bottlenecks and understand the scalability properties of your system.

Demystifying Performance Evaluation: A Collaborative Effort

The performance evaluation feature leverages a powerful combination of data sources to create an accurate picture of your application's performance:

  • Telemetry Data: The Evento server persistently collects telemetry data about the execution time of handlers (components that process commands or events) and the invocation frequencies of these handlers within Flows. This data provides a real-world understanding of how long it takes for specific actions to occur and how often they are triggered.

  • Flow Structure: The flow structure, as defined within your Evento application, outlines the sequence of interactions between components. This structure serves as a roadmap, allowing Evento to understand the interconnected nature of these interactions and how they contribute to the overall processing flow.

By analyzing this combined data, Evento builds a performance evaluation model. This model acts as a virtual representation of your application's performance characteristics.

Optimizing Throughput: Throughput Settings and Bottleneck Detection

The performance evaluation page within the Evento GUI offers functionalities to leverage the power of the performance evaluation model:

  • Throughput Settings: You can specify the desired throughput (number of requests processed per unit time) for each Flow within your application. This allows you to define performance targets and identify Flows that might become bottlenecks if the workload increases.

  • Bottleneck Detection: Based on the performance evaluation model, Evento can detect potential bottlenecks within your application. Bottlenecks are components or sections of Flows that become overloaded when the workload increases, hindering the overall performance. By identifying these bottlenecks, you can prioritize optimization efforts and ensure your application scales effectively.

Beyond the Page: Performance Optimization Strategies

The performance evaluation feature empowers you to make informed decisions about optimizing your Evento application. Here are some strategies you can employ:

  • Horizontal Scaling: By increasing the number of bundle instances, you can distribute the workload across more resources, potentially alleviating bottlenecks.

  • Component Optimization: If a specific component is identified as a bottleneck, you might explore techniques like code optimization or caching to improve its performance.

  • Flow Redesign: In some cases, redesigning the flow structure itself might be necessary to optimize the sequence of interactions and reduce processing overhead.

Conclusion: A Guide to a Performant Evento Application

The performance evaluation feature, working hand-in-hand with Flows, serves as a powerful tool for optimizing your Evento application. By leveraging telemetry data, flow structure, and performance evaluation models, you gain valuable insights into your application's performance characteristics. This knowledge empowers you to identify bottlenecks, set throughput targets, and make informed decisions that ensure your application scales effectively to meet growing demands. As your Evento application evolves, the performance evaluation feature will remain your trusted companion, guiding you towards a performant and optimized system.