Nservicebus at scale
•Download as PPTX, PDF•
0 likes•488 views
This document discusses NServiceBus at scale. It covers why the speaker's company adopted NServiceBus, how they monitored and tuned their system using it, and an integration example with a payment service provider. Some lessons learned included managing code dependencies, testing asynchronous and long-running processes, and deploying distributed transaction coordinators.
Report
Share
Report
Share
Recommended
Zing Me Real Time Web Chat Architect
This document discusses the architecture of Zing Me's web chat platform. It has over 45 million registered users and handles over 500 servers. The web chat uses a connection server implemented in C++ with epoll to handle over 100,000 concurrent connections through long polling. It also uses a friend online server and message server. The message server stores messages and notifies of new messages through queues. Workers then deliver messages to users via the connection server. The architecture was developed over several months by multiple teams to provide real-time messaging capabilities at scale for Zing Me.
Efficiently downloading and executing Javascript
The document discusses different techniques for efficiently downloading and executing Javascript resources on a webpage. It compares approaches like using script tags to join Javascript files, injecting scripts asynchronously, triggering scripts with callbacks, downloading scripts in parallel and deferring execution. The goal is to reduce blocking of DOM loading, enable parallel downloads, decrease load time and share cached resources across pages. Various tradeoffs of blocking DOM loading, parallelization, load time and resource sharing are considered for each approach.
Types of replication, pooling and ha
Review of different technologies for replication, connection pooling and implementation of high availability.
Server architecture
The document discusses server architecture and different types of servers. It describes common server roles like web servers, application servers, and proxy servers. It provides examples of simple web servers written in Node.js and Ruby. Popular web servers mentioned include Nginx and Apache. Different hosting options for servers are also covered, such as virtual dedicated servers (VDS), virtual private servers (VPS), and cloud servers hosted on platforms like Amazon AWS, Google Cloud, and Microsoft Azure.
02 vng thanhnt-speedup_ntvv2_by_ph_pextmodule_
This document discusses speeding up the ZingMe-NTVV2 application by writing a PHP extension module. It introduces NTVV2, which has high traffic volumes. Writing a PHP extension can make complicated business functions run faster and use less memory compared to pure PHP. The document explains what a PHP extension is, its lifecycle, and how to set up the build environment. It recommends using SWIG, an interface compiler, to more easily connect C/C++ programs to PHP. SWIG allows defining types, wrapping classes/functions, and exposing functions to PHP. The document provides steps for using SWIG, including defining the module, generating code, creating a project, and compiling. Caching data in the PHP module
#4 Mulesoft Virtual Meetup Kolkata December 2020
The document summarizes the agenda and content of a MuleSoft meetup group meeting in Kolkata. The agenda included introductions, a presentation on integrating applications using Anypoint MQ, and best practices for secure properties in MuleSoft. The Anypoint MQ presentation covered topics like publish-subscribe integration patterns, using Anypoint MQ for publishing and subscribing to messages, acknowledgement modes, and comparisons to other message queues. It included a demo and a question and answer session. The meeting concluded with a trivia quiz, notices about sharing on social media, and requesting feedback.
Web performance optimization - MercadoLibre
The document provides techniques and tools for improving web performance. It discusses how reducing response times can directly impact revenues and user experience. It then covers various ways to optimize the frontend, including reducing time to first byte through DNS optimization and caching, using content delivery networks, HTTP compression, keeping connections alive, parallel downloads, and prefetching. It also discusses optimizing images, JavaScript loading, and introducing new formats like WebP. The overall document aims to educate on measuring and enhancing web performance.
Web Crypto
Karl von Randow's talk on Web Crypto for Auckland Web Dev Nights on the 9th of May 2013.
http://webdevnights.github.io
Recommended
Zing Me Real Time Web Chat Architect
This document discusses the architecture of Zing Me's web chat platform. It has over 45 million registered users and handles over 500 servers. The web chat uses a connection server implemented in C++ with epoll to handle over 100,000 concurrent connections through long polling. It also uses a friend online server and message server. The message server stores messages and notifies of new messages through queues. Workers then deliver messages to users via the connection server. The architecture was developed over several months by multiple teams to provide real-time messaging capabilities at scale for Zing Me.
Efficiently downloading and executing Javascript
The document discusses different techniques for efficiently downloading and executing Javascript resources on a webpage. It compares approaches like using script tags to join Javascript files, injecting scripts asynchronously, triggering scripts with callbacks, downloading scripts in parallel and deferring execution. The goal is to reduce blocking of DOM loading, enable parallel downloads, decrease load time and share cached resources across pages. Various tradeoffs of blocking DOM loading, parallelization, load time and resource sharing are considered for each approach.
Types of replication, pooling and ha
Review of different technologies for replication, connection pooling and implementation of high availability.
Server architecture
The document discusses server architecture and different types of servers. It describes common server roles like web servers, application servers, and proxy servers. It provides examples of simple web servers written in Node.js and Ruby. Popular web servers mentioned include Nginx and Apache. Different hosting options for servers are also covered, such as virtual dedicated servers (VDS), virtual private servers (VPS), and cloud servers hosted on platforms like Amazon AWS, Google Cloud, and Microsoft Azure.
02 vng thanhnt-speedup_ntvv2_by_ph_pextmodule_
This document discusses speeding up the ZingMe-NTVV2 application by writing a PHP extension module. It introduces NTVV2, which has high traffic volumes. Writing a PHP extension can make complicated business functions run faster and use less memory compared to pure PHP. The document explains what a PHP extension is, its lifecycle, and how to set up the build environment. It recommends using SWIG, an interface compiler, to more easily connect C/C++ programs to PHP. SWIG allows defining types, wrapping classes/functions, and exposing functions to PHP. The document provides steps for using SWIG, including defining the module, generating code, creating a project, and compiling. Caching data in the PHP module
#4 Mulesoft Virtual Meetup Kolkata December 2020
The document summarizes the agenda and content of a MuleSoft meetup group meeting in Kolkata. The agenda included introductions, a presentation on integrating applications using Anypoint MQ, and best practices for secure properties in MuleSoft. The Anypoint MQ presentation covered topics like publish-subscribe integration patterns, using Anypoint MQ for publishing and subscribing to messages, acknowledgement modes, and comparisons to other message queues. It included a demo and a question and answer session. The meeting concluded with a trivia quiz, notices about sharing on social media, and requesting feedback.
Web performance optimization - MercadoLibre
The document provides techniques and tools for improving web performance. It discusses how reducing response times can directly impact revenues and user experience. It then covers various ways to optimize the frontend, including reducing time to first byte through DNS optimization and caching, using content delivery networks, HTTP compression, keeping connections alive, parallel downloads, and prefetching. It also discusses optimizing images, JavaScript loading, and introducing new formats like WebP. The overall document aims to educate on measuring and enhancing web performance.
Web Crypto
Karl von Randow's talk on Web Crypto for Auckland Web Dev Nights on the 9th of May 2013.
http://webdevnights.github.io
Log Files
Log files provide insights into systems like web servers and databases by recording details of requests, responses, and operations over time. They can be used for monitoring systems, troubleshooting issues, and analyzing usage patterns. However, the large volumes of log data produced require efficient processing and aggregation approaches to gain these insights in real-time or through batch analysis. Common techniques include shipping logs to a central aggregator, using group communication protocols for real-time distribution, and batch processing with Hadoop/MapReduce.
Monitoring microservices
Microservices are a great way to design your system so that it can scale. But once those pieces are in production, how do you know if all the different pieces are working properly? Are some metrics more important than others, and what story can each of the metrics tell you? This talk shows you some tools and techniques to monitor distributed systems
#OSSPARIS19 - How to improve database observability - CHARLES JUDITH, Criteo
#OSSPARIS19 - How to improve database observability - CHARLES JUDITH, CriteoParis Open Source Summit
The document discusses improving database observability. It recommends collecting metrics like utilization, saturation, errors, latency, traffic, and errors using methods like USE, RED, and the seven golden signals. These metrics can be collected via tools like Collectd and exported to dashboards. Logs of SQL queries and slow queries should also be collected and analyzed. The goal is to increase transparency and visibility of the database to help users and developers and improve monitoring and reliability. Future work includes enhancing SQL logging, using sys_schema, publishing SLAs, and open sourcing monitoring probes.sat_presentation
The document discusses various topics related to processes, programming, debugging, automation, and system management. It addresses questions around following processes, defining metrics, debugging memory leaks, automating tasks, managing system availability, and handling errors. Troubleshooting techniques like breakpoints and tracing code are also covered. The document seeks to explore different aspects of developing, maintaining and managing the performance of systems and applications.
Are you weak in the middle?
This document discusses using message-oriented middleware for transaction processing in heterogeneous environments. It defines different types of middleware, focusing on message-oriented middleware which includes message brokers. The document presents a case study of Peer Mobile AB, which uses Apache ActiveMQ for reliable, scalable transaction processing across distributed systems. Key features of ActiveMQ that make it suitable are also summarized. Benchmarking showed the system can process over 1,500 transactions per second through distributed, clustered architecture.
OSMC 2019 | How to improve database Observability by Charles Judith
Delivering a database service is not a simple job but to ensure that everything is working correctly your platform needs to be observable. In this talk, I’ll talk about how we make the MySQL/MariaDB databases observable. We’ll talk about the RED, USE methods, and the golden signals. You’ll discover how we dealt with the following questions “We think the database is slow”. This talk will allow you to make your databases discoverable with open source solutions.
Bringing Learnings from Googley Microservices with gRPC - Varun Talwar, Google
Varun Talwar, product manager on Google's gRPC project discusses the fundamentals and specs of gRPC inside of a Google-scale microservices architecture.
Messaging is not just for investment banks!
This document discusses how messaging can be used for more than just investment banks. It provides examples of how messaging can improve application integration and decouple processes for better performance, scalability, and resilience compared to traditional HTTP integration. Specific benefits highlighted include better isolation, asynchronous processing, guaranteed delivery, and improved testability. Case studies demonstrate how messaging can solve problems with email delivery after registration and credit card processing. Common messaging tools and situations where messaging is applicable are also outlined.
Design patterns for scaling web applications
This document discusses various patterns for scaling web applications. It begins by describing single machine, two-tier, and multi-tier web application architectures. It then covers message bus and service-oriented architectures. The document discusses scaling up approaches like identifying bottlenecks, utilizing bottlenecks, adjusting non-bottlenecks, elevating bottlenecks, and reviewing processes. Specific scaling techniques covered include caching, threading and queues, and using content delivery networks.
Microservices Architecture
A brief intro to microservice patters and strategies.
This is a presentation from the series "by Developer for Developers" powered by eSolutions Grup.
You can find the practical example at https://github.com/eSolutionsGrup/microshop
Fluent 2018: When third parties stop being polite... and start getting real
Fluent 2018: When third parties stop being polite... and start getting realAkamai Developers & Admins
At Fluent Conference 2018, Nic Jansma and Charles Vazac perform an honest audit of several popular third-party libraries to understand their true cost to your site, exploring loading patterns, SPOF avoidance, JavaScript parsing, long tasks, runtime overhead, polyfill headaches, security and privacy concerns, and more. They also share tools to help you decide if a library’s risks and unseen costs are worth it.When Third Parties Stop Being Polite... and Start Getting Real
By Nic Jansma and Charlie Vazac (Akamai)
Fluent 2018
Would you give the Amazon Prime delivery robot the key to your house, just because it stops by to deliver delicious packages every day? Even if you would, do you still have 100% confidence that it wouldn’t accidentally drag in some mud, let the neighbor in, steal your things, or burn your house down? Worst-case scenarios such as these are what you should be planning for when deciding whether or not to include third-party libraries and services on your website. While most libraries have good intentions, by including them on your site, you have given them complete control over the kingdom. Once on your site, they can provide all of the great services you want—or they can destroy everything you’ve worked so hard to build.
It’s prudent to be cautious: we’ve all heard stories about how third-party libraries have caused slowdowns, broken websites, and even led to downtime. But how do you evaluate the actual costs and potential risks of a third-party library so you can balance that against the service it provides? Every library requires nonzero overhead to provide the service it claims. In many cases, the overhead is minimal and justified, but we should quantify it to understand the real cost. In addition, libraries need to be carefully crafted so they can avoid causing additional pain when the stars don’t align and things go wrong.
Nic Jansma and Charles Vazac perform an honest audit of several popular third-party libraries to understand their true cost to your site, exploring loading patterns, SPOF avoidance, JavaScript parsing, long tasks, runtime overhead, polyfill headaches, security and privacy concerns, and more. From how the library is loaded, to the moment it phones home, you’ll see how third-parties can affect the host page and discover best practices you can follow to ensure they do the least potential harm.
With all of the great performance tools available to developers today, we’ve gained a lot of insight into just how much third-party libraries are impacting our websites. Nic and Charles detail tools to help you decide if a library’s risks and unseen costs are worth it. While you may not have the time to perform a deep dive into every third-party library you want to include on your site, you’ll leave with a checklist of the most important best practices third-parties should be following for you to have confidence in them.
Microsoft Infrastructure Monitoring using OpManager
Microsoft is a well known vendor in Enterprise IT market. This presentation explains how to monitor Microsoft products using ManageEngine OpManager. and basic of Microsoft infrastructure monitoring.
When third parties stop being polite... and start getting real
By Nic Jansma and Charles Vazac (Akamai)
Fluent 2018
http://www.youtube.com/watch?v=L3LKtFh1HkQ
Would you give the Amazon Prime delivery robot the key to your house, just because it stops by to deliver delicious packages every day? Even if you would, do you still have 100% confidence that it wouldn’t accidentally drag in some mud, let the neighbor in, steal your things, or burn your house down? Worst-case scenarios such as these are what you should be planning for when deciding whether or not to include third-party libraries and services on your website. While most libraries have good intentions, by including them on your site, you have given them complete control over the kingdom. Once on your site, they can provide all of the great services you want—or they can destroy everything you’ve worked so hard to build.
It’s prudent to be cautious: we’ve all heard stories about how third-party libraries have caused slowdowns, broken websites, and even led to downtime. But how do you evaluate the actual costs and potential risks of a third-party library so you can balance that against the service it provides? Every library requires nonzero overhead to provide the service it claims. In many cases, the overhead is minimal and justified, but we should quantify it to understand the real cost. In addition, libraries need to be carefully crafted so they can avoid causing additional pain when the stars don’t align and things go wrong.
Nic Jansma and Charles Vazac perform an honest audit of several popular third-party libraries to understand their true cost to your site, exploring loading patterns, SPOF avoidance, JavaScript parsing, long tasks, runtime overhead, polyfill headaches, security and privacy concerns, and more. From how the library is loaded, to the moment it phones home, you’ll see how third-parties can affect the host page and discover best practices you can follow to ensure they do the least potential harm.
With all of the great performance tools available to developers today, we’ve gained a lot of insight into just how much third-party libraries are impacting our websites. Nic and Charles detail tools to help you decide if a library’s risks and unseen costs are worth it. While you may not have the time to perform a deep dive into every third-party library you want to include on your site, you’ll leave with a checklist of the most important best practices third-parties should be following for you to have confidence in them.
Continuous delivery of Windows micro services in the cloud
Chef london meetup talk about windows micro services and continuous delivery at justgiving, and the journey we took
Microservice
The document discusses microservices and some of the challenges of moving to a microservices architecture. It describes what microservices are and how decomposing an application into loosely coupled services can help deliver changes rapidly and reliably. However, distributing an application in this way introduces challenges around distributed data, consistency, and event-driven messaging. Patterns like sagas, event sourcing and CQRS are discussed as ways to help maintain consistency when data is distributed across multiple microservices.
Instruments to play microservice
This document discusses microservices architecture and the various tools needed to build microservices. It begins by explaining the pros and cons of monolith applications versus microservices. It then covers requirements for building microservices like security, asynchronous communication, monitoring, logging, tracing, service discovery, configuration management, and circuit breakers. Specific open source tools are mentioned for each requirement area, including RabbitMQ, Kafka, Prometheus, Zipkin, Elasticsearch, Eureka, Spring Cloud Config, and Kubernetes. The document concludes by asking if the audience has any additional questions.
Agile Gurugram 2023 | Observability for Modern Applications. How does it help...
This document discusses observability for modern applications. It begins by defining observability as the ability to observe what is happening inside a system. Observability helps measure key performance indicators and allows teams to react faster to issues. In cloud native environments, observability fits by instrumenting applications to capture logs, traces, metrics and health data which are then transmitted to analytics tools. The document outlines the different pillars of application instrumentation - logs to see what happened, traces to see how it happened, metrics to see how much happened, and health checks to see system status. It discusses OpenTelemetry as an open source observability framework to address prior vendor lock-in issues and competing standards.
Training Webinar: Detect Performance Bottlenecks of Applications
In this webinar we look at how to detect and troubleshoot server-side performance bottlenecks.
Free Online training: https://www.outsystems.com/learn/courses/
Follow us on Twitter http://www.twitter.com/OutSystemsDev
Like us on Facebook http://www.Facebook.com/OutSystemsDev
Introduction to event based microservices
We will discuss the advantages and disadvantages of microservices compared to monolithic architecture. Finally we will try to mitigate the disadvantages of microservices using an event based approach.
Scaling for Success: Lessons from handling peak loads on Azure with NServiceBus
What happens when 200k users unexpectedly decide to use your platform simultaneously? We’re using autoscale on Azure PaaS so surely we can handle that, right? Wrong! Ask me how I found out… After going through a bit of trouble, I want to help you avoid the same mistakes I made.
Beyond simple benchmarks—a practical guide to optimizing code
We know it’s vital that code executed at scale performs well. But how do we know if our performance optimizations actually make it faster? Fortunately, we have powerful tools which help—BenchmarkDotNet is a .NET library for benchmarking optimizations, with many simple examples to help get started.
In most systems, the code we need to optimize is rarely straightforward. It contains assumptions we need to discover before we even know what to improve. The code is hard to isolate. It has dependencies, which may or may not be relevant to optimization. And even when we’ve decided what to optimize, it’s hard to reliably benchmark the before and after. Only measurements can tell us if our changes actually make things faster. Without them, we could even make things slower, without realizing.
In this webinar you’ll learn how to:
- Identify areas of improvement which optimize the effort-to-value ratio
- Isolate code to make its performance measurable without extensive refactoring
- Apply the performance loop of measuring, changing and validating to ensure performance actually improves and nothing breaks
- Gradually become more “performance aware” without costing an arm and a leg
More Related Content
Similar to Nservicebus at scale
Log Files
Log files provide insights into systems like web servers and databases by recording details of requests, responses, and operations over time. They can be used for monitoring systems, troubleshooting issues, and analyzing usage patterns. However, the large volumes of log data produced require efficient processing and aggregation approaches to gain these insights in real-time or through batch analysis. Common techniques include shipping logs to a central aggregator, using group communication protocols for real-time distribution, and batch processing with Hadoop/MapReduce.
Monitoring microservices
Microservices are a great way to design your system so that it can scale. But once those pieces are in production, how do you know if all the different pieces are working properly? Are some metrics more important than others, and what story can each of the metrics tell you? This talk shows you some tools and techniques to monitor distributed systems
#OSSPARIS19 - How to improve database observability - CHARLES JUDITH, Criteo
#OSSPARIS19 - How to improve database observability - CHARLES JUDITH, CriteoParis Open Source Summit
The document discusses improving database observability. It recommends collecting metrics like utilization, saturation, errors, latency, traffic, and errors using methods like USE, RED, and the seven golden signals. These metrics can be collected via tools like Collectd and exported to dashboards. Logs of SQL queries and slow queries should also be collected and analyzed. The goal is to increase transparency and visibility of the database to help users and developers and improve monitoring and reliability. Future work includes enhancing SQL logging, using sys_schema, publishing SLAs, and open sourcing monitoring probes.sat_presentation
The document discusses various topics related to processes, programming, debugging, automation, and system management. It addresses questions around following processes, defining metrics, debugging memory leaks, automating tasks, managing system availability, and handling errors. Troubleshooting techniques like breakpoints and tracing code are also covered. The document seeks to explore different aspects of developing, maintaining and managing the performance of systems and applications.
Are you weak in the middle?
This document discusses using message-oriented middleware for transaction processing in heterogeneous environments. It defines different types of middleware, focusing on message-oriented middleware which includes message brokers. The document presents a case study of Peer Mobile AB, which uses Apache ActiveMQ for reliable, scalable transaction processing across distributed systems. Key features of ActiveMQ that make it suitable are also summarized. Benchmarking showed the system can process over 1,500 transactions per second through distributed, clustered architecture.
OSMC 2019 | How to improve database Observability by Charles Judith
Delivering a database service is not a simple job but to ensure that everything is working correctly your platform needs to be observable. In this talk, I’ll talk about how we make the MySQL/MariaDB databases observable. We’ll talk about the RED, USE methods, and the golden signals. You’ll discover how we dealt with the following questions “We think the database is slow”. This talk will allow you to make your databases discoverable with open source solutions.
Bringing Learnings from Googley Microservices with gRPC - Varun Talwar, Google
Varun Talwar, product manager on Google's gRPC project discusses the fundamentals and specs of gRPC inside of a Google-scale microservices architecture.
Messaging is not just for investment banks!
This document discusses how messaging can be used for more than just investment banks. It provides examples of how messaging can improve application integration and decouple processes for better performance, scalability, and resilience compared to traditional HTTP integration. Specific benefits highlighted include better isolation, asynchronous processing, guaranteed delivery, and improved testability. Case studies demonstrate how messaging can solve problems with email delivery after registration and credit card processing. Common messaging tools and situations where messaging is applicable are also outlined.
Design patterns for scaling web applications
This document discusses various patterns for scaling web applications. It begins by describing single machine, two-tier, and multi-tier web application architectures. It then covers message bus and service-oriented architectures. The document discusses scaling up approaches like identifying bottlenecks, utilizing bottlenecks, adjusting non-bottlenecks, elevating bottlenecks, and reviewing processes. Specific scaling techniques covered include caching, threading and queues, and using content delivery networks.
Microservices Architecture
A brief intro to microservice patters and strategies.
This is a presentation from the series "by Developer for Developers" powered by eSolutions Grup.
You can find the practical example at https://github.com/eSolutionsGrup/microshop
Fluent 2018: When third parties stop being polite... and start getting real
Fluent 2018: When third parties stop being polite... and start getting realAkamai Developers & Admins
At Fluent Conference 2018, Nic Jansma and Charles Vazac perform an honest audit of several popular third-party libraries to understand their true cost to your site, exploring loading patterns, SPOF avoidance, JavaScript parsing, long tasks, runtime overhead, polyfill headaches, security and privacy concerns, and more. They also share tools to help you decide if a library’s risks and unseen costs are worth it.When Third Parties Stop Being Polite... and Start Getting Real
By Nic Jansma and Charlie Vazac (Akamai)
Fluent 2018
Would you give the Amazon Prime delivery robot the key to your house, just because it stops by to deliver delicious packages every day? Even if you would, do you still have 100% confidence that it wouldn’t accidentally drag in some mud, let the neighbor in, steal your things, or burn your house down? Worst-case scenarios such as these are what you should be planning for when deciding whether or not to include third-party libraries and services on your website. While most libraries have good intentions, by including them on your site, you have given them complete control over the kingdom. Once on your site, they can provide all of the great services you want—or they can destroy everything you’ve worked so hard to build.
It’s prudent to be cautious: we’ve all heard stories about how third-party libraries have caused slowdowns, broken websites, and even led to downtime. But how do you evaluate the actual costs and potential risks of a third-party library so you can balance that against the service it provides? Every library requires nonzero overhead to provide the service it claims. In many cases, the overhead is minimal and justified, but we should quantify it to understand the real cost. In addition, libraries need to be carefully crafted so they can avoid causing additional pain when the stars don’t align and things go wrong.
Nic Jansma and Charles Vazac perform an honest audit of several popular third-party libraries to understand their true cost to your site, exploring loading patterns, SPOF avoidance, JavaScript parsing, long tasks, runtime overhead, polyfill headaches, security and privacy concerns, and more. From how the library is loaded, to the moment it phones home, you’ll see how third-parties can affect the host page and discover best practices you can follow to ensure they do the least potential harm.
With all of the great performance tools available to developers today, we’ve gained a lot of insight into just how much third-party libraries are impacting our websites. Nic and Charles detail tools to help you decide if a library’s risks and unseen costs are worth it. While you may not have the time to perform a deep dive into every third-party library you want to include on your site, you’ll leave with a checklist of the most important best practices third-parties should be following for you to have confidence in them.
Microsoft Infrastructure Monitoring using OpManager
Microsoft is a well known vendor in Enterprise IT market. This presentation explains how to monitor Microsoft products using ManageEngine OpManager. and basic of Microsoft infrastructure monitoring.
When third parties stop being polite... and start getting real
By Nic Jansma and Charles Vazac (Akamai)
Fluent 2018
http://www.youtube.com/watch?v=L3LKtFh1HkQ
Would you give the Amazon Prime delivery robot the key to your house, just because it stops by to deliver delicious packages every day? Even if you would, do you still have 100% confidence that it wouldn’t accidentally drag in some mud, let the neighbor in, steal your things, or burn your house down? Worst-case scenarios such as these are what you should be planning for when deciding whether or not to include third-party libraries and services on your website. While most libraries have good intentions, by including them on your site, you have given them complete control over the kingdom. Once on your site, they can provide all of the great services you want—or they can destroy everything you’ve worked so hard to build.
It’s prudent to be cautious: we’ve all heard stories about how third-party libraries have caused slowdowns, broken websites, and even led to downtime. But how do you evaluate the actual costs and potential risks of a third-party library so you can balance that against the service it provides? Every library requires nonzero overhead to provide the service it claims. In many cases, the overhead is minimal and justified, but we should quantify it to understand the real cost. In addition, libraries need to be carefully crafted so they can avoid causing additional pain when the stars don’t align and things go wrong.
Nic Jansma and Charles Vazac perform an honest audit of several popular third-party libraries to understand their true cost to your site, exploring loading patterns, SPOF avoidance, JavaScript parsing, long tasks, runtime overhead, polyfill headaches, security and privacy concerns, and more. From how the library is loaded, to the moment it phones home, you’ll see how third-parties can affect the host page and discover best practices you can follow to ensure they do the least potential harm.
With all of the great performance tools available to developers today, we’ve gained a lot of insight into just how much third-party libraries are impacting our websites. Nic and Charles detail tools to help you decide if a library’s risks and unseen costs are worth it. While you may not have the time to perform a deep dive into every third-party library you want to include on your site, you’ll leave with a checklist of the most important best practices third-parties should be following for you to have confidence in them.
Continuous delivery of Windows micro services in the cloud
Chef london meetup talk about windows micro services and continuous delivery at justgiving, and the journey we took
Microservice
The document discusses microservices and some of the challenges of moving to a microservices architecture. It describes what microservices are and how decomposing an application into loosely coupled services can help deliver changes rapidly and reliably. However, distributing an application in this way introduces challenges around distributed data, consistency, and event-driven messaging. Patterns like sagas, event sourcing and CQRS are discussed as ways to help maintain consistency when data is distributed across multiple microservices.
Instruments to play microservice
This document discusses microservices architecture and the various tools needed to build microservices. It begins by explaining the pros and cons of monolith applications versus microservices. It then covers requirements for building microservices like security, asynchronous communication, monitoring, logging, tracing, service discovery, configuration management, and circuit breakers. Specific open source tools are mentioned for each requirement area, including RabbitMQ, Kafka, Prometheus, Zipkin, Elasticsearch, Eureka, Spring Cloud Config, and Kubernetes. The document concludes by asking if the audience has any additional questions.
Agile Gurugram 2023 | Observability for Modern Applications. How does it help...
This document discusses observability for modern applications. It begins by defining observability as the ability to observe what is happening inside a system. Observability helps measure key performance indicators and allows teams to react faster to issues. In cloud native environments, observability fits by instrumenting applications to capture logs, traces, metrics and health data which are then transmitted to analytics tools. The document outlines the different pillars of application instrumentation - logs to see what happened, traces to see how it happened, metrics to see how much happened, and health checks to see system status. It discusses OpenTelemetry as an open source observability framework to address prior vendor lock-in issues and competing standards.
Training Webinar: Detect Performance Bottlenecks of Applications
In this webinar we look at how to detect and troubleshoot server-side performance bottlenecks.
Free Online training: https://www.outsystems.com/learn/courses/
Follow us on Twitter http://www.twitter.com/OutSystemsDev
Like us on Facebook http://www.Facebook.com/OutSystemsDev
Introduction to event based microservices
We will discuss the advantages and disadvantages of microservices compared to monolithic architecture. Finally we will try to mitigate the disadvantages of microservices using an event based approach.
Similar to Nservicebus at scale (20)
#OSSPARIS19 - How to improve database observability - CHARLES JUDITH, Criteo
#OSSPARIS19 - How to improve database observability - CHARLES JUDITH, Criteo
OSMC 2019 | How to improve database Observability by Charles Judith
OSMC 2019 | How to improve database Observability by Charles Judith
Bringing Learnings from Googley Microservices with gRPC - Varun Talwar, Google
Bringing Learnings from Googley Microservices with gRPC - Varun Talwar, Google
Fluent 2018: When third parties stop being polite... and start getting real
Fluent 2018: When third parties stop being polite... and start getting real
When Third Parties Stop Being Polite... and Start Getting Real
When Third Parties Stop Being Polite... and Start Getting Real
Microsoft Infrastructure Monitoring using OpManager
Microsoft Infrastructure Monitoring using OpManager
When third parties stop being polite... and start getting real
When third parties stop being polite... and start getting real
Continuous delivery of Windows micro services in the cloud
Continuous delivery of Windows micro services in the cloud
Agile Gurugram 2023 | Observability for Modern Applications. How does it help...
Agile Gurugram 2023 | Observability for Modern Applications. How does it help...
Training Webinar: Detect Performance Bottlenecks of Applications
Training Webinar: Detect Performance Bottlenecks of Applications
More from Particular Software
Scaling for Success: Lessons from handling peak loads on Azure with NServiceBus
What happens when 200k users unexpectedly decide to use your platform simultaneously? We’re using autoscale on Azure PaaS so surely we can handle that, right? Wrong! Ask me how I found out… After going through a bit of trouble, I want to help you avoid the same mistakes I made.
Beyond simple benchmarks—a practical guide to optimizing code
We know it’s vital that code executed at scale performs well. But how do we know if our performance optimizations actually make it faster? Fortunately, we have powerful tools which help—BenchmarkDotNet is a .NET library for benchmarking optimizations, with many simple examples to help get started.
In most systems, the code we need to optimize is rarely straightforward. It contains assumptions we need to discover before we even know what to improve. The code is hard to isolate. It has dependencies, which may or may not be relevant to optimization. And even when we’ve decided what to optimize, it’s hard to reliably benchmark the before and after. Only measurements can tell us if our changes actually make things faster. Without them, we could even make things slower, without realizing.
In this webinar you’ll learn how to:
- Identify areas of improvement which optimize the effort-to-value ratio
- Isolate code to make its performance measurable without extensive refactoring
- Apply the performance loop of measuring, changing and validating to ensure performance actually improves and nothing breaks
- Gradually become more “performance aware” without costing an arm and a leg
An exception occurred - Please try again
If there is one certainty in software, it's that things fail. It's not a matter of if but when. All too often, we throw the error at our users, who have no means of solving the problem except for trying again. Alternatively, we build custom code to address edge cases that can't easily be fixed, and we do so with a dangerous lack of insight into the problem at hand.
In this session, we'll discuss the importance of system resilience and how you can equip your software with the ability to recover from failure scenarios. After exploring different types of failures and considering different resilience strategies, we'll dig deeper into the retry pattern by rolling our own. We'll also see existing options, such as Polly and NServiceBus, that can handle this complexity for you.
Join me and embrace your system's failures.
Tales from the trenches creating complex distributed systems
Developing complex distributed systems is hard. There are many challenges. How do we identify and tackle them? How do others do it?
Got the time?
“Have all my overdue invoices been paid?” Seems a simple enough question. But once you factor in the effects of time, even the simplest question can turn into a mess of edge cases and complicated batch jobs that never quite complete on time.
Implementing outbox model-checking first
This document discusses implementing an "Outbox" pattern using model checking to ensure correctness. It describes how traditional two-phase commit is insufficient to handle anomalies like duplication and reordering. The Outbox approach uses transport and data store transactions along with publishing to address edge cases. Model checking with TLA+ specification language is advocated over just automated tests to model system states and verify properties like no duplicated processing. Several demos are presented to illustrate issues like ghost messages, lost messages, and consistent output.
Reports from the field azure functions in practice
Serverless is the new hotness, but are Azure Functions right for your system?
Presented by Adam Jones, Chief Technology Officer for LHP Telematics, LLC based in Westfield, IN.
Finding your service boundaries - a practical guide
We know it's useful to split up complex systems. We've seen the benefits of modular deployment of microservices. Dealing with only one piece of code at a time eases our cognitive load. But how do we know where to draw the service boundaries? In complex business domains, it's often difficult to know where to start. When we get our boundaries wrong, the clocks starts ticking. Before long, we hear ourselves say "it would be easier to re-write it".
Join Adam for practical advice on discovering the hidden boundaries in your systems. Help tease out the natural separation of concerns in a sample business domain. During 20 years of developing complex systems, Adam has had plenty of time to get things wrong. Learn to avoid the common pitfalls that can lead us down the path to "the big re-write".
Webinar recording: https://particular.net/webinars/finding-your-service-boundaries-a-practical-guide
Decomposing .NET Monoliths with NServiceBus and Docker
Monoliths are hard work. They're difficult to understand, brittle to change, time-consuming to test and risky to deploy. And you're stuck with the monolith's tech stack so you can't use any modern architectures or technologies.
Decomposing monoliths is easy if you take the right approach, and it results in a distributed solution with many small components. Those can be independently updated, tested and deployed, which means you release better software, more quickly.
You'll learn about:
- The right approach to decomposition
- the feature-driven approach, powered by Docker and NServiceBus
- How to run your monolith in a container
- How to extract features into new components
- How to plug components together with NServiceBus and run the whole stack in Docker containers
DIY Async Message Pump: Lessons from the trenches
Daniel Marbach shows the differences between theory and practice when building a reliable message pump that consumes and produces messages from queues.
Share the insight of ServiceInsight
Trygve Lorentzen shows how he designs systems that the developers, support team, and decision makers at ProTeria can easily understand with the help of ServiceInsight.
What to consider when monitoring microservices
William Brander and Sean Farmar show how the monitoring game changes when a system becomes distributed and you start delving into the world of microservices.
Learn:
* Why monitoring changes in distributed systems
* A monitoring philosophy that ensures all bases are covered
* The aspects of monitoring that affect asynchronous messaging systems
Making communications across boundaries simple with NServiceBus
There are times when you should consider setting up secure communications between your software components across network boundaries.
Here are just a few:
* Your application is enormous (e.g., the global deployment of a marketing site targeting billions of people)
* Remoteness (e.g., your company has branch office locations around the globe)
* Your network constraints prevent communication (e.g., your machines in Azure Cloud Services are unable to talk to each other directly)
* You don't know the network conditions (e.g., IoT or mobile devices)
Yves Goeleven and Sean Feldman show how to overcome such challenges using NServiceBus.
Making communication across boundaries simple with Azure Service Bus
There are times when you should consider setting up secure communications between your software components across network boundaries.
Here are just a few:
* Your application is enormous (e.g., the global deployment of a marketing site targeting billions of people)
* Remoteness (e.g., your company has branch office locations around the globe)
* Your network constraints prevent communication (e.g., your machines in Azure Cloud Services are unable to talk to each other directly)
* You don't know the network conditions (e.g., IoT or mobile devices)
Yves Goeleven and Sean Feldman show how to overcome such challenges using Azure Service Bus.
How to avoid microservice pitfalls
There are many resources out there that walk you through the process of setting up distributed systems, queuing and asynchronous processes — with and without NServiceBus.
Despite all the online education, teams continue to make the same common mistakes when designing and implementing microservices architecture. While the mistakes can have devastating consequences, they are easy to avoid when approached intentionally.
Jeffrey Palermo and Justin Self share their experiences in overcoming common microservices pitfalls and show how NServiceBus naturally encourages better architecture, such as easy adherence to SOLID principles.
Learn:
* What a microservice really is (and is not)
* What mistakes teams commonly make
* How to avoid the pitfalls and design more robust and scalable architecture
* How to equip your team for a microservices architecture
Connect front end to back end using SignalR and Messaging
If you've ever worked on a message-based system, at some point you have probably asked the question: How can I connect my asynchronous back-end to the front-end?
This webinar is focused on answering this non-trivial question, outlining scenarios and solutions available in our toolbox to easily make the back-end talk to the front-end in a way that is both robust and scalable.
The cornerstone of the system we will study in this webinar is SignalR, a library that facilitates adding bi-directional communication between the server and the browser over the WebSocket protocol. We will also see how NServiceBus messaging framework can be used in combination with SignalR.
When the basic scenario is up and running, we will venture into making the system scale to many server instances. We will introduce the concept of a backplane that forwards messages to all server instances so that a client connected to one instance can receive messages sent from another one. We will implement the SignalR backplane using Redis, a popular open source in-memory key-value store.
Learn how to:
* Connect back-end systems to the frontend
* Use correlation, and why it's important
* Use SignalR with message-based systems
* Use SignalR with NServiceBus
* Achieve real time notifications in a JavaScript SPA
* Provide user feedback in web applications
Async/Await: NServiceBus v6 API Update
A lot is changing in NServiceBus v6, especially with the changes required to support asynchronous message processing with Async/Await.
Daniel Marbach shows how the v6 API update helps to avoid common Async/Await pitfalls and makes your code ready for the asynchronous APIs in the cloud.
Learn how to:
* Leverage the new asynchronous APIs to avoid common Async/Await pitfalls
* Maximize the message throughput by using asynchronous APIs concurrently in your handlers
* Write synchronous code in the new asynchronous message handlers
* and last but not least, see how this relates to delicious Swiss Chocolate.
If you're an existing NServiceBus user and you want to be well prepared to migrate your solutions to the latest version of NServiceBus, or you're a complete newbie to NServiceBus and want to see how it can help you avoid common Async/Await pitfalls — don't miss this webinar!
Async/Await: TPL & Message Pumps
Daniel Marbach showa how to combine Async/Await together with the Task Parallel Library to create a message pump for a service bus.
Learn how to:
* Deal with non-true asynchronous code paths
* Avoid unpleasant surprises when you combined Async/Await with the Task Parallel Library
* Achieve "graceful" shutdowns by applying cancellation to the asynchronous operations
* Achieve throttling with your concurrent operations without blocking unnecessarily
If you want to learn how a message pump built can be built with Async/Await and the Task Parallel Library looks like — don't miss this webinar!
Async/Await Best Practices
Daniel Marbach shows how to avoid common pitfalls in asynchronous code bases.
Learn how to:
* Differentiate between IO-bound vs CPU-bound work and how this relates to Threads and Tasks
* Avoid serious production bugs as a result of asynchronous methods returning void
* Opt-out from context capturing when necessary
* Deal with synchronous code in the context of asynchronous code
Making workflow implementation easy with CQRS
Andrea Saltarello shows how to evolve systems architecture leveraging CQRS principles and NServiceBus Sagas.
More from Particular Software (20)
Scaling for Success: Lessons from handling peak loads on Azure with NServiceBus
Scaling for Success: Lessons from handling peak loads on Azure with NServiceBus
Beyond simple benchmarks—a practical guide to optimizing code
Beyond simple benchmarks—a practical guide to optimizing code
Tales from the trenches creating complex distributed systems
Tales from the trenches creating complex distributed systems
Reports from the field azure functions in practice
Reports from the field azure functions in practice
Finding your service boundaries - a practical guide
Finding your service boundaries - a practical guide
Decomposing .NET Monoliths with NServiceBus and Docker
Decomposing .NET Monoliths with NServiceBus and Docker
Making communications across boundaries simple with NServiceBus
Making communications across boundaries simple with NServiceBus
Making communication across boundaries simple with Azure Service Bus
Making communication across boundaries simple with Azure Service Bus
Connect front end to back end using SignalR and Messaging
Connect front end to back end using SignalR and Messaging
Recently uploaded
Observability Concepts EVERY Developer Should Know -- DeveloperWeek Europe.pdf
Monitoring and observability aren’t traditionally found in software curriculums and many of us cobble this knowledge together from whatever vendor or ecosystem we were first introduced to and whatever is a part of your current company’s observability stack.
While the dev and ops silo continues to crumble….many organizations still relegate monitoring & observability as the purview of ops, infra and SRE teams. This is a mistake - achieving a highly observable system requires collaboration up and down the stack.
I, a former op, would like to extend an invitation to all application developers to join the observability party will share these foundational concepts to build on:
Artificial Intelligence for XMLDevelopment
In the rapidly evolving landscape of technologies, XML continues to play a vital role in structuring, storing, and transporting data across diverse systems. The recent advancements in artificial intelligence (AI) present new methodologies for enhancing XML development workflows, introducing efficiency, automation, and intelligent capabilities. This presentation will outline the scope and perspective of utilizing AI in XML development. The potential benefits and the possible pitfalls will be highlighted, providing a balanced view of the subject.
We will explore the capabilities of AI in understanding XML markup languages and autonomously creating structured XML content. Additionally, we will examine the capacity of AI to enrich plain text with appropriate XML markup. Practical examples and methodological guidelines will be provided to elucidate how AI can be effectively prompted to interpret and generate accurate XML markup.
Further emphasis will be placed on the role of AI in developing XSLT, or schemas such as XSD and Schematron. We will address the techniques and strategies adopted to create prompts for generating code, explaining code, or refactoring the code, and the results achieved.
The discussion will extend to how AI can be used to transform XML content. In particular, the focus will be on the use of AI XPath extension functions in XSLT, Schematron, Schematron Quick Fixes, or for XML content refactoring.
The presentation aims to deliver a comprehensive overview of AI usage in XML development, providing attendees with the necessary knowledge to make informed decisions. Whether you’re at the early stages of adopting AI or considering integrating it in advanced XML development, this presentation will cover all levels of expertise.
By highlighting the potential advantages and challenges of integrating AI with XML development tools and languages, the presentation seeks to inspire thoughtful conversation around the future of XML development. We’ll not only delve into the technical aspects of AI-powered XML development but also discuss practical implications and possible future directions.
20240609 QFM020 Irresponsible AI Reading List May 2024
Everything I found interesting about the irresponsible use of machine intelligence in May 2024
Microsoft - Power Platform_G.Aspiotis.pdf
Revolutionizing Application Development
with AI-powered low-code, presentation by George Aspiotis, Sr. Partner Development Manager, Microsoft
HCL Notes and Domino License Cost Reduction in the World of DLAU
Webinar Recording: https://www.panagenda.com/webinars/hcl-notes-and-domino-license-cost-reduction-in-the-world-of-dlau/
The introduction of DLAU and the CCB & CCX licensing model caused quite a stir in the HCL community. As a Notes and Domino customer, you may have faced challenges with unexpected user counts and license costs. You probably have questions on how this new licensing approach works and how to benefit from it. Most importantly, you likely have budget constraints and want to save money where possible. Don’t worry, we can help with all of this!
We’ll show you how to fix common misconfigurations that cause higher-than-expected user counts, and how to identify accounts which you can deactivate to save money. There are also frequent patterns that can cause unnecessary cost, like using a person document instead of a mail-in for shared mailboxes. We’ll provide examples and solutions for those as well. And naturally we’ll explain the new licensing model.
Join HCL Ambassador Marc Thomas in this webinar with a special guest appearance from Franz Walder. It will give you the tools and know-how to stay on top of what is going on with Domino licensing. You will be able lower your cost through an optimized configuration and keep it low going forward.
These topics will be covered
- Reducing license cost by finding and fixing misconfigurations and superfluous accounts
- How do CCB and CCX licenses really work?
- Understanding the DLAU tool and how to best utilize it
- Tips for common problem areas, like team mailboxes, functional/test users, etc
- Practical examples and best practices to implement right away
Let's Integrate MuleSoft RPA, COMPOSER, APM with AWS IDP along with Slack
Discover the seamless integration of RPA (Robotic Process Automation), COMPOSER, and APM with AWS IDP enhanced with Slack notifications. Explore how these technologies converge to streamline workflows, optimize performance, and ensure secure access, all while leveraging the power of AWS IDP and real-time communication via Slack notifications.
National Security Agency - NSA mobile device best practices
Threats to mobile devices are more prevalent and increasing in scope and complexity. Users of mobile devices desire to take full advantage of the features
available on those devices, but many of the features provide convenience and capability but sacrifice security. This best practices guide outlines steps the users can take to better protect personal devices and information.
Communications Mining Series - Zero to Hero - Session 1
This session provides introduction to UiPath Communication Mining, importance and platform overview. You will acquire a good understand of the phases in Communication Mining as we go over the platform with you. Topics covered:
• Communication Mining Overview
• Why is it important?
• How can it help today’s business and the benefits
• Phases in Communication Mining
• Demo on Platform overview
• Q/A
GraphRAG for Life Science to increase LLM accuracy
GraphRAG for life science domain, where you retriever information from biomedical knowledge graphs using LLMs to increase the accuracy and performance of generated answers
Infrastructure Challenges in Scaling RAG with Custom AI models
Building Retrieval-Augmented Generation (RAG) systems with open-source and custom AI models is a complex task. This talk explores the challenges in productionizing RAG systems, including retrieval performance, response synthesis, and evaluation. We’ll discuss how to leverage open-source models like text embeddings, language models, and custom fine-tuned models to enhance RAG performance. Additionally, we’ll cover how BentoML can help orchestrate and scale these AI components efficiently, ensuring seamless deployment and management of RAG systems in the cloud.
GraphSummit Singapore | Graphing Success: Revolutionising Organisational Stru...
Sudheer Mechineni, Head of Application Frameworks, Standard Chartered Bank
Discover how Standard Chartered Bank harnessed the power of Neo4j to transform complex data access challenges into a dynamic, scalable graph database solution. This keynote will cover their journey from initial adoption to deploying a fully automated, enterprise-grade causal cluster, highlighting key strategies for modelling organisational changes and ensuring robust disaster recovery. Learn how these innovations have not only enhanced Standard Chartered Bank’s data infrastructure but also positioned them as pioneers in the banking sector’s adoption of graph technology.
Building Production Ready Search Pipelines with Spark and Milvus
Spark is the widely used ETL tool for processing, indexing and ingesting data to serving stack for search. Milvus is the production-ready open-source vector database. In this talk we will show how to use Spark to process unstructured data to extract vector representations, and push the vectors to Milvus vector database for search serving.
20240607 QFM018 Elixir Reading List May 2024
Everything I found interesting about the Elixir programming ecosystem in May 2024
Uni Systems Copilot event_05062024_C.Vlachos.pdf
Unlocking Productivity: Leveraging the Potential of Copilot in Microsoft 365, a presentation by Christoforos Vlachos, Senior Solutions Manager – Modern Workplace, Uni Systems
Cosa hanno in comune un mattoncino Lego e la backdoor XZ?
ABSTRACT: A prima vista, un mattoncino Lego e la backdoor XZ potrebbero avere in comune il fatto di essere entrambi blocchi di costruzione, o dipendenze di progetti creativi e software. La realtà è che un mattoncino Lego e il caso della backdoor XZ hanno molto di più di tutto ciò in comune.
Partecipate alla presentazione per immergervi in una storia di interoperabilità, standard e formati aperti, per poi discutere del ruolo importante che i contributori hanno in una comunità open source sostenibile.
BIO: Sostenitrice del software libero e dei formati standard e aperti. È stata un membro attivo dei progetti Fedora e openSUSE e ha co-fondato l'Associazione LibreItalia dove è stata coinvolta in diversi eventi, migrazioni e formazione relativi a LibreOffice. In precedenza ha lavorato a migrazioni e corsi di formazione su LibreOffice per diverse amministrazioni pubbliche e privati. Da gennaio 2020 lavora in SUSE come Software Release Engineer per Uyuni e SUSE Manager e quando non segue la sua passione per i computer e per Geeko coltiva la sua curiosità per l'astronomia (da cui deriva il suo nickname deneb_alpha).
Programming Foundation Models with DSPy - Meetup Slides
Prompting language models is hard, while programming language models is easy. In this talk, I will discuss the state-of-the-art framework DSPy for programming foundation models with its powerful optimizers and runtime constraint system.
GraphSummit Singapore | Neo4j Product Vision & Roadmap - Q2 2024
Maruthi Prithivirajan, Head of ASEAN & IN Solution Architecture, Neo4j
Get an inside look at the latest Neo4j innovations that enable relationship-driven intelligence at scale. Learn more about the newest cloud integrations and product enhancements that make Neo4j an essential choice for developers building apps with interconnected data and generative AI.
Why You Should Replace Windows 11 with Nitrux Linux 3.5.0 for enhanced perfor...
The choice of an operating system plays a pivotal role in shaping our computing experience. For decades, Microsoft's Windows has dominated the market, offering a familiar and widely adopted platform for personal and professional use. However, as technological advancements continue to push the boundaries of innovation, alternative operating systems have emerged, challenging the status quo and offering users a fresh perspective on computing.
One such alternative that has garnered significant attention and acclaim is Nitrux Linux 3.5.0, a sleek, powerful, and user-friendly Linux distribution that promises to redefine the way we interact with our devices. With its focus on performance, security, and customization, Nitrux Linux presents a compelling case for those seeking to break free from the constraints of proprietary software and embrace the freedom and flexibility of open-source computing.
Presentation of the OECD Artificial Intelligence Review of Germany
Consult the full report at https://www.oecd.org/digital/oecd-artificial-intelligence-review-of-germany-609808d6-en.htm
Recently uploaded (20)
Observability Concepts EVERY Developer Should Know -- DeveloperWeek Europe.pdf
Observability Concepts EVERY Developer Should Know -- DeveloperWeek Europe.pdf
20240609 QFM020 Irresponsible AI Reading List May 2024
20240609 QFM020 Irresponsible AI Reading List May 2024
HCL Notes and Domino License Cost Reduction in the World of DLAU
HCL Notes and Domino License Cost Reduction in the World of DLAU
Let's Integrate MuleSoft RPA, COMPOSER, APM with AWS IDP along with Slack
Let's Integrate MuleSoft RPA, COMPOSER, APM with AWS IDP along with Slack
National Security Agency - NSA mobile device best practices
National Security Agency - NSA mobile device best practices
Communications Mining Series - Zero to Hero - Session 1
Communications Mining Series - Zero to Hero - Session 1
GraphRAG for Life Science to increase LLM accuracy
GraphRAG for Life Science to increase LLM accuracy
Infrastructure Challenges in Scaling RAG with Custom AI models
Infrastructure Challenges in Scaling RAG with Custom AI models
GraphSummit Singapore | Graphing Success: Revolutionising Organisational Stru...
GraphSummit Singapore | Graphing Success: Revolutionising Organisational Stru...
Building Production Ready Search Pipelines with Spark and Milvus
Building Production Ready Search Pipelines with Spark and Milvus
Cosa hanno in comune un mattoncino Lego e la backdoor XZ?
Cosa hanno in comune un mattoncino Lego e la backdoor XZ?
Programming Foundation Models with DSPy - Meetup Slides
Programming Foundation Models with DSPy - Meetup Slides
GraphSummit Singapore | Neo4j Product Vision & Roadmap - Q2 2024
GraphSummit Singapore | Neo4j Product Vision & Roadmap - Q2 2024
Why You Should Replace Windows 11 with Nitrux Linux 3.5.0 for enhanced perfor...
Why You Should Replace Windows 11 with Nitrux Linux 3.5.0 for enhanced perfor...
Presentation of the OECD Artificial Intelligence Review of Germany
Presentation of the OECD Artificial Intelligence Review of Germany
Nservicebus at scale
- 2. About Me Charlie Barker Twitter: @porkstone Blog: http://dualbotic.com
- 3. What will this talk cover? Why we adopted NServiceBus Monitoring / Tuning Integration Example with a PSP Lessons Learned
- 4. How our platform used to communicate Website Back Office Decision Engine XML/HTTP XML/HTTP Third party services
- 6. Why NServiceBus? ● Udi says ● Robust ● Distributed ● Opinionated ● Training ● Community
- 7. Monitoring / Tuning ● Added more granular events ● Used WMI to send data ● Aggregated data every minute ● Exceptions by Message Type ● Allowed us to find bottlenecks quickly ● Allowed us to predict SLA failure
- 8. Predict Failure Point SLA Breach 1 7 14 21 28 % Busy Time Day of the month
- 11. Detailed View - Message Type Breakdown
- 12. Detailed View - Single Message
- 13. Metrics available for endpoint as a whole ● %Busy Time ● %Idle Time ● Critical Time(s)
- 14. Metrics for endpoints + individual messages ● Count ● Percentage of time ● Average Duration
- 15. Count Metrics ● Message Count ● Errors Count ● Retries Count ● Handler Failures Count
- 16. Percentage of time metrics ● Message deserialisation time ● Message handler time ● Message commit time ● Message processing time ● Failed message processing time
- 17. Average Duration metrics ● Avg message deserialize (ms) ● Avg message handler (ms) ● Avg message commit (ms) ● Avg message processing (ms) ● Avg failed message processing (ms)
- 18. Ivica
- 20. Endpoints Engine Bot HTTP Payment Service Provider NSB v3.3.5 RavenDB 2.0
- 23. RavenDB
- 25. Creating the missing docs
- 27. Payment Collection Saga - Start/Stop
- 28. Payment Collection Saga - Timeout
- 29. Lessons Learned ● Code dependencies ● Testing Async ● Testing Long Running Processes ● Deploying the DTC ● Rewrite from scratch?
- 30. What would I like to see in the future?
- 31. Questions?
- 32. fin
Editor's Notes
- "Percentage of time" metrics These metrics report the average percentage of the entire available time an endpoint is spending performing specific message-processing tasks (see note on % Busy Time further below on how percentage timekeeping is performed) % Msg Deser Time - percentage of time spent deserialising message XML bodies. This time is usually tiny relative to other components. % Msg Handler Time - percentage of time spent executing a message handler. This is the component the endpoint developer has direct control over. % Msg Commit Time - percentage of time spent inside MSDTC commiting a successful message. This time is usually 1/10th of the overall Msg processing time - if it gets bigger than that, it signifies potential problems with the MSDTC. % Msg Proc Time - percentage of time spent processing successful messages. This is a sum of ( % Msg Deser Time + % Msg Handler Time + % Msg Commit Time ). % Failed Msg Proc Time - percentage of time spent processing messages that have failed.
- "Average (ms) duration" metrics These metrics report average duration (in miliseconds) of the same message-processing tasks in the previous slide. A rarely occurring but long-running message type can be under-represented in the "percentage" metrics, but it will clearly stand out in the "average (ms) duration" ones. These counters are particularly useful for troubleshooting individual message types that are taking too long to execute, or are failing after a timeout. These can be easily pinpointed by enabling "Avg Msg Proc (ms)" and "Avg Failed Msg Proc (ms)" counters in the "message breakdown" view.
- It would be unfair of me not to mention the talented engineer who built the majority of this monitoring solution - Ivica Nikolic