Forem: Raygun

Part one: 7 must-know object-oriented software patterns (and their pitfalls)

Raygun Staff — Tue, 08 Aug 2023 20:13:09 +0000

The importance of object-oriented design patterns in software development

Object-oriented (not orientated!) design is a fundamental principle of modern software engineering, a crucial concept that all developers need to understand and employ effectively. Software design patterns like object-oriented design serve as universal solutions to common problems, across a range of instances and domains. As software engineers advance in their careers, they actually often start using these patterns instinctively, even without knowing it.

However, there’s a tough balance to strike. A developer who lacks knowledge or experience with these object-oriented design patterns often strays into suboptimal, ad-hoc solutions that violate key software engineering principles, such as code reusability and separation of concerns, potentially resulting in harder long-term maintenance.

On the other hand, misusing these patterns or applying them too rigidly can cause unnecessary complexity, resulting in tangled code with too many layers of abstraction. Overuse can make the codebase difficult to understand and navigate, slowing down development and increasing the likelihood of errors.

In part one of this article, we'll explore 4 of the most common object-oriented programming patterns using an array of example programming languages. We'll discuss how to apply these patterns in your software development effectively, compare them to ad hoc solutions, and demonstrate some common antipatterns that result from misuse or overuse. Our goal is to provide you with a comprehensive understanding of these patterns, help you avoid common pitfalls, and equip you with best practices to apply these patterns effectively in your development work.

This is part one of a thorough, 2-part exploration of these OOP patterns, covering the extension design pattern, the singleton pattern, the exception shielding pattern and the object pool pattern. Find part two here, exploring composite bridge, iterator and lock design patterns.

In this post:

Extension Method
Singleton
Exception Shielding
Object Pool

Wrapping up

1. Extension method {#extension-method}

Defining the extension design pattern

The extension method is a design pattern that solves a common problem: adding functionality to an existing class without modifying its source code. This is especially useful when you don’t have access to the original class source code or need to add functionality to a system type.

Using the extension design pattern

The extension method must be used judiciously. It’s tempting to lean on this object-oriented pattern as a convenient way to add functionality to a class, even when you have direct access to the class' source code. Overuse or misuse of the extension method can lead to unnecessary complexity, resulting in a convoluted code structure that’s difficult to understand and navigate. This is a stark example of how the inappropriate application of a design pattern can hinder development and increase the risk of errors.

Use the Extension Method with care. It's well-suited for small utilities or for extending system types, but not for types that you own and can modify directly. Instead, aim to extend the actual class with new methods, preserving code cleanliness and maintainability and adhering to object-oriented programming best practices.

Without

As an illustrative example of the extension design pattern in C#, let's look at a case-insensitive string comparison. In a direct approach, the developer might use the Equals method with an extra parameter for StringComparison.OrdinalIgnoreCase. This works, but can get clunky with repeated use. We could also create a new static method for comparing two strings, but this would violate object-oriented principles by decoupling data from functionality.

{{< highlight csharp>}}
string myString = "TeSt!";

/* Ad Hoc Option 1 */
if (myString.Equals("test!", StringComparison.OrdinalIgnoreCase)) { … }

/* Ad Hoc Option 2 */
if (NewStaticMethodEqualsIgnoreCase(myString, "test!")) { … }  
{{< /highlight >}}

With

Instead, an elegant solution uses the Extension Method. We can create a new method, EqualsIgnoreCase, which extends the string class, yielding natural and readable code while preserving the object-oriented principle of associating data with functionality.

{{< highlight csharp>}}
public static class StringExtensions
{
    public static bool EqualsIgnoreCase(this string str, string compareWith)
    {
        return str.Equals(compareWith, StringComparison.OrdinalIgnoreCase);
    }
}

string myString = "TeSt!";
if (myString.EqualsIgnoreCase("test!")) { … }
{{< /highlight >}}

Antipattern

We still need to beware of falling into antipatterns. The extension method is not a one-size-fits-all solution. When a developer owns a class and needs to perform data manipulation entirely within the scope of that class, it’s more appropriate to add a new method within the class itself, rather than resorting to an extension method. This ensures we’re leveraging object-oriented design, keeping related data and functionality together in a logical and maintainable way.

{{< highlight csharp>}}
public class Customer
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

public static class CustomerExtensions
{
    public static string GetFullName(this Customer customer)
    {
        return $"{customer.FirstName} {customer.LastName}";
    }
}
{{< /highlight >}}

Instead

{{< highlight csharp>}}
public class Customer
{
    public string FirstName { get; set; }
    public string LastName { get; set; }

    public string GetFullName()
    {
        return $"{FirstName} {LastName}";
    }
}
{{< /highlight >}}

2. Singleton {#singleton}

Defining the singleton pattern

The purpose of the Singleton pattern in software design is enforcement of a single instance (i.e., object) of a class throughout a running application. It also provides a global point of access to this instance, making it easily accessible across different components of the system.

Using the singleton pattern

The singleton pattern is helpful where we need a single point of control or coordination, like database connections or logging services. It streamlines these processes by ensuring that the same instance is used consistently across different parts of the software, promoting coherency and reducing potential for error.

However, the Singleton pattern, like all tools, can be misused. It's common, and dangerous, to view the Singleton as a catch-all place for code that doesn't quite fit elsewhere. This can lead to a Singleton that's overburdened and difficult to manage, filled with miscellaneous code that should be organized better. This dumping ground strategy can also make the Singleton hard to test and prone to concurrency issues, given its global accessibility.

Without

Here’s a common scenario in Java, where a developer needs to log events across an application. An initial approach might be to simply create new Logger objects as needed and then discard them once they've served their purpose. This approach, while seemingly straightforward, can lead to problems.

Repeatedly creating and discarding Logger objects can result in subpar performance due to the overhead associated with object creation and garbage collection. Even worse, it can lead to synchronization issues. As various Logger instances write to the log, entries could overlap and become muddled, creating a garbled, confusing log.

{{< highlight shell>}}
void myFunction() {
    …
    Logger logger = new Logger(...);
    logger.log("Message"); /*Potential synchronization conflicts!*/
    …
}
{{< /highlight >}}

With

A more efficient solution is to employ the Singleton pattern for our Logger. This way, we create a single instance of the Logger class and store it in a static field within the class itself. To enforce the Singleton behavior, we mark the constructor as private. This prevents any external invocations, stopping additional Logger instances from being created.

Access to the singleton Logger is then managed through a synchronized getInstance method. Synchronization ensures thread-safety, preventing race conditions that could create multiple Logger instances simultaneously.

The Singleton approach also allows a streamlined initialization process for various logging mechanisms. In our example, we need to log events both to Raygun's Crash Reporting service and to local disk storage. Using a Singleton Logger, we can manage both efficiently from a central location.

{{< highlight shell>}}
public class Logger {
    private static Logger instance;
    private RaygunClient raygunClient;
    private DiskLogging diskLogging;

    private Logger() {
        raygunClient = new RaygunClient("api-key");
        diskLogging = new DiskLogging(...);
    }

    public static synchronized Logger getInstance() {
        if (instance == null) {
                instance = new Logger();
        }
        return instance;
    }

    public void log(String message) {
        raygunClient.send(message);
        diskLogging.write(message);
    }
}

Logger.getInstance().log("Message");
{{< /highlight >}}

Antipattern

While widely used, Singleton critics label it an antipattern. They argue it encourages global state, making the code unpredictable and violating the Single Responsibility Principle. Singletons can also generate concurrency issues, obfuscate dependencies, and complicate refactoring efforts due to their pervasive presence in the codebase. However, Singleton can still be helpful in the right context.

Misuse of the Singleton pattern can violate the tenets of object-oriented design. A common pitfall is using the Singleton as a global data dump, transforming it into a code equivalent of an overstuffed closet. This is clearly illustrated in our example, where the Logger instance has been burdened with a mishmash of global fields that don’t align with its primary function.

Consider the following Java code:

{{< highlight java>}}
public class Logger {
    private static Logger instance;
    …
    private long lastTimeAUserLoggedIn;
    private String applicationReleaseVersion;
    private Object someGlobalObjectADevAddedTenVersionsAgo;
    …
}

Logger.getInstance().someGlobalObjectADevAddedTenVersionsAgo.wtf();
{{< /highlight >}}

Here, the Logger Singleton has been laden with fields such as lastTimeAUserLoggedIn, applicationReleaseVersion, and a vague someGlobalObjectADevAddedTenVersionsAgo. The presence of these fields in the Logger class not only muddles the class's purpose but also makes the system confusing and hard to maintain. Developers are left puzzling over the purpose of someGlobalObjectADevAddedTenVersionsAgo and why it's even part of the Logger class. This is a prime example of how misusing the Singleton pattern can lead to bloated and confusing code.

Instead

A more sophisticated approach to handle global configurations like the applicationReleaseVersion is to use Java's built-in Properties class. This allows you to maintain a set of key-value pairs where both are Strings, making it an ideal choice for storing configuration data.

In this context, we can have a Singleton class AppConfig that encapsulates a Properties object. The Properties object can be populated at the startup of the application, loading key-value pairs from a configuration file. This not only promotes separation of concerns but also allows the configurations to be easily modified without changing the source code.

Here's an example of how to structure the AppConfig Singleton class in Java:

{{< highlight java>}}
public class AppConfig {
    private static AppConfig instance;
    private static final RaygunClient raygunClient = new RaygunClient("API-KEY");

    private Properties properties;

    private AppConfig() {
        properties = new Properties();
        try (InputStream input = getClass().getClassLoader().getResourceAsStream("app.config")) {
            if (input == null) {
                raygunClient.send("Unable to find config file!");
                return;
            }

            //load properties from the config file
            properties.load(input);
        } catch (IOException ex) {
            raygunClient.send(ex);
        }
    }

    public static synchronized AppConfig getInstance() {
        if (instance == null) {
            instance = new AppConfig();
        }
        return instance;
    }

    public String getProperty(String key) {
        return properties.getProperty(key);
    }
}
{{< /highlight >}}

In th
is example, the `AppConfig` class loads key-value pairs from a file named app.config located in the classpath at the startup of the application. Then we can use the `getProperty` method to retrieve the application's version or any other configuration data as needed:

{{< highlight java>}}
String applicationVersion = AppConfig.getInstance().getProperty("applicationReleaseVersion");
{{< /highlight >}}

This not only promotes better organization and separation of concerns but also provides a flexible and efficient way to manage application configurations.

3. Exception Shielding{#exception-shielding}

Defining the exception shielding pattern

The exception shielding design pattern aims to prevent the spread of sensitive or unnecessary exception information beyond the architectural boundaries of a system. This is particularly essential in user-facing systems, like web apps, where unhandled exceptions can reveal sensitive details about the system’s inner workings or result in a poor user experience. Exception shielding ensures that the user only sees meaningful, non-sensitive error information.

Using the exception shielding pattern

A key rule of thumb when implementing exception shielding is to only catch exceptions that you can meaningfully handle. This means exceptions where your code can either recover from the error, perform some mitigation steps, or enrich the exception details before rethrowing it. Avoid blanket-catching all exceptions without any handling logic, as this can lead to silently swallowed errors, making debugging a nightmarish process.

Every exception that you catch but can't handle properly should be logged or recorded. Ignoring an exception, or catching it only to rethrow a less specific one without a fix or logging can bury crucial diagnostic information. Effective exception handling should balance protecting the system and preserving information.

Without

Let's consider the following Node.js Express application route handler, designed to fetch and display a customer's data based on their ID.

{{< highlight js>}}
app.get('/customer/:id', (req, res) => {
    const customerId = req.params.id;
    res.send(displayCustomer(customerId);
});
{{< /highlight >}}

While this route handler is straightforward and concise, it doesn't include any exception handling. This means if something goes wrong within the displayCustomer function, like a database error, or if the customer with the provided ID doesn't exist, an error will be thrown. This unhandled error can potentially crash the entire application, or at least interrupt its normal operation.

Plus, depending on the configuration of your server, this unhandled error might expose sensitive details to the end user, like database schema information or proprietary business logic. This could mean a significant security risk and a poor user experience, sending raw error messages instead of a helpful, user-friendly response.

Antipattern

Let's break down Exception Shielding further via two common antipatterns: Exception Swallowing and Incorrect Exception Chaining or Exception Wrapping. These antipatterns illustrate misuse of try-catch blocks, and even though they can satisfy compiler requirements, they often introduce more problems than they solve.

Antipattern 1: Exception Swallowing

In the following Node.js code snippet, a try-catch block is used, but the catch block is left empty. This is known as exception swallowing. While the code will still run, it can lead to unseen errors, making debugging difficult.

{{< highlight js>}}
/* Antipattern 1: Exception Swallowing*/
app.get('/customer/:id', (req, res) => {
    const customerId = req.params.id;
    var response = "";
    try {
        response = displayCustomer(customerId);
    } catch (err) {
        /*Do Nothing! Exception Swallowed…*/
    } finally {
        res.send(response);
    }
});
{{< /highlight >}}

Antipattern 2: Incorrect Exception Chaining or Exception Wrapping

Incorrect Exception Chaining (or Exception Wrapping) happens when a new generic error is thrown, instead of correctly handling an exception or passing it along with sufficient information. This discards any valuable details from the original error, including its stack trace.

{{< highlight js>}}
/* Antipattern 2: Exception Chaining or Exception Wrapping*/
/*Creating, throwing new exception discards info in original*/
} catch (err) {
    throw new Error("My error text");
}
{{< /highlight >}}

With/Instead

The exception shielding design pattern, when used correctly, can significantly enhance your application's robustness and user experience. Below, we're applying this pattern in a Node.js web application, using Raygun error monitoring.

{{< highlight js>}}
const raygun = require('raygun');
const raygunClient = new raygun.Client().init({ apiKey: 'api-key' });

app.get('/customer/:id', (req, res) => {
    const customerId = req.params.id;
    try {
        const response = displayCustomer(customerId);
        res.send(response);
    } catch (err) {
        raygunClient.send(err);
        res.status(500).send('Error while processing your request.');
    }
});
{{< /highlight >}}

In the above code, any exceptions thrown during the execution of displayCustomer are caught and logged by Raygun. The user-facing response, however, is a generic 500 error message, free of any unnecessary or sensitive exception information.

If you need to throw a new error, always try to attach the original error to preserve useful debugging information. Here's an example:

{{< highlight js>}}
/*Alternatively, if new Error must be thrown, attach the original to it*/
} catch (err) {
    raygunClient.send(err);
    const higherLevelError = new Error('A higher level error occurred');
    higherLevelError.originalError = err;
    throw higherLevelError;
}
{{< /highlight >}}

In this snippet, we create a new error, but also keep a reference to the original error. This retains the valuable debugging information from the initial error, even as we raise a new error to be handled at a higher level of our application.

4. Object Pool{#object-pool}

Defining the object pool pattern

The object pool design pattern provides an efficient way to manage resources that are expensive to create and release. It recycles objects that are no longer in use, reducing the costly overhead of resource acquisition and release. Examples could be database connections, thread pools, or large bitmap objects.

Using the object pool pattern

However, like our other object-oriented design patterns, we should use object pool only in the right context. It isn't a universal solution for all types of objects. Some language runtimes provide a multitude of optimizations that work "under-the-hood". For example, in C++ and C#, objects can be allocated on the stack, offering better performance in certain scenarios compared to an object pool.

Without

In the example provided, we have a class Enemy in C++ (inspired by the efficacy of the object pool pattern in game development). To create an instance of the class, we use the new keyword which triggers the constructor, allocating memory on the heap and initializing the new object. Once we're done using the object, we call delete to deallocate the memory.

This is effective for simple applications or when the Enemy instances are infrequently created and destroyed. However, it has its issues, particularly for performance-critical applications or those creating and destroying a large number of instances in short time spans.

Each call to create and delete involves memory allocation and deallocation operations which are expensive in terms of CPU time. If this is happening frequently, it can lead to significant performance overhead. Repeated allocation and deallocation of memory can also lead to heap fragmentation, which can degrade performance over time.

{{< highlight cpp>}}
class Enemy {
private:
    …
public:
    Enemy() {
        …
    }

    ~Enemy() {
        …
    }
}

Enemy* enemy = new Enemy();
…
delete enemy;
{{< /highlight >}}

With

In this revised object pool example, we implement an EnemyPool class (which falls under the object pool design pattern). Instead of creating and destroying Enemy objects each time we need them, we pre-allocate a pool of Enemy instances and recycle them. This can dramatically reduce the overhead of frequent memory allocation and deallocation.

In the constructor of EnemyPool, a specified number of Enemy objects are pre-allocated and stored in a stack data structure for use when needed. The getEnemy method retrieves an Enemy object from the stack if one is available, otherwise it throws an error. Once the Enemy object is no longer needed, it's returned to the pool using the returnEnemy method, where it gets pushed back onto the stack for reuse.

The destructor of EnemyPool ensures that all the Enemy objects are properly deleted when the EnemyPool object goes out of scope. This prevents memory leaks.

{{< highlight cpp>}}
class EnemyPool {
private:
    std::stack<Enemy*> available;

public:
    EnemyPool(int size) {
        for (int i = 0; i < size; ++i) {
            available.push(new Enemy());
        }
    }

    ~EnemyPool() {
        while (!available.empty()) {
            delete available.top();
            available.pop();
        }
    }

    Enemy* getEnemy() {
        if (available.empty()) {
            throw std::runtime_error("No enemies available");
        }

        Enemy* enemy = available.top();
        available.pop();

        return enemy;
    }

    void returnEnemy(Enemy* enemy) {
        available.push(enemy);
    }
};
{{< /highlight >}}

This design pattern is beneficial for performance-critical applications or if we’re creating and destroying a large number of instances rapidly. It reduces the number of memory allocation and deallocation operations, mitigates heap fragmentation, and generally increases application speed and efficiency. But be careful not to hold onto Enemy objects for longer than necessary, to ensure that there are always enough available in the pool.

Antipattern

The misuse of the Object Pool pattern can lead to unnecessary complexity and potential memory leaks. The antipattern presented here shows an Enemy object being borrowed from the EnemyPool and then returned back to the pool within a function. This may seem correct, but it poses a few problems.

A big issue arises if an exception gets thrown or an early return is encountered within the function, skipping the returnEnemy method. In this case, we end up with a memory leak as the Enemy object is never returned to the pool and can’t be reclaimed.

{{< highlight cpp>}}
void functionLocalEnemy(EnemyPool enemyPool) {
    const enemy = enemyPool.getEnemy();
    …
    enemyPool.returnEnemy(enemy);
}
{{< /highlight >}}

Instead

Instead of using the Object Pool pattern in this situation, you can try a simpler approach. If the scope of an object is limited to a single function or block, it might be more efficient and safer to allocate it on the stack. When you declare an Enemy object inside a function like functionLocalEnemy, the Enemy instance is created on the stack when the function is entered and automatically deallocated when the function exits. This stack-based allocation and deallocation is handled by the runtime, so there's no need to remember to deallocate the object manually, preventing potential memory leaks.

{{< highlight cpp>}}
void functionLocalEnemy(EnemyPool enemyPool) {
    Enemy enemy; /*Allocate on the stack*/
    …
} /*Stack object automatically deallocated on function exit*/
{{< /highlight >}}

Wrapping up{#wrap}

That’s the first 4 of our 7 essential object-oriented software patterns, and you should now have a solid grasp of the extension method, singleton, exception shielding, and object pool design patterns. (You can find part two here, exploring composite bridge, iterator and lock design patterns.) These patterns, used appropriately, provide robust solutions to common challenges, leading to more efficient and resilient software development. These are among the most common object oriented design patterns for good reason, and serve as vital tools in a developer's arsenal, promoting code reusability, separation of concerns, and overall software engineering best practices.

However, we have to reiterate how important it is to be discerning in the application of these patterns. As shown by our examples, misuse or over-application can lead to a tangle of complexity, obscuring the simplicity and clarity that characterizes good code. A proficient software engineer understands when a pattern adds value and when it might obscure the essence of the code. Striking a balance between robust design patterns and clean, simple code is a show of serious engineering finesse, and is a skill to practise and hone over time.

To assist in this process, developers can leverage software intelligence tools like Raygun Crash Reporting, which can provide deep insights into your application's health, alerting you when things go wrong and helping you diagnose the root cause of issues more efficiently. Raygun's Real User Monitoring (RUM) tool can provide valuable insights into how your application performs in real-world conditions, helping you understand where performance bottlenecks may exist and guiding optimization efforts. And lastly, Raygun's Application Performance Monitoring (APM) tool can give you the visibility you need to understand how effectively your design patterns are performing in your live environment, alerting you to any issues before they become problematic. Take a 14-day trial of Raygun, no credit card needed, for free here.

With the intelligent use of design patterns and the powerful insights offered by Raygun's tools you'll be building bulletproof software that is efficient, maintainable, and high quality. Happy coding!

Author & Affiliations
Dr. Panos Patros, CPEng
Principal Engineer, Raygun
New Zealand Adjunct Professor in Computer Science, IBM Center of Advanced Studies-Atlantic, UNB
Canada Steering Committee Member, IT Engineers, Engineering New Zealand

Announcing Ruby support for Raygun APM

Raygun Staff — Thu, 26 Nov 2020 23:18:11 +0000

We’ve built Raygun APM to be the best solution on the market today, with more code-level detail, better visualization, and powerful infrastructure that helps developers discover and diagnose performance bottlenecks in a fraction of the time — and for a fraction of the cost.

That’s why we are thrilled to launch the next chapter in our ongoing support for Application Performance Monitoring: Ruby support for Raygun APM. Ruby teams can now get end-to-end monitoring with features like detailed trace transactions, dashboards, code execution, and more.

These features normally cost thousands per month with a traditional APM tool. But with Raygun’s usage-based pricing model, you can now get sophisticated Ruby performance monitoring for a more efficient price — no matter what your environment looks like.

How is Raygun APM different?

When we first launched APM, we knew we needed to be better than other APM solutions on the market.

As a technical team ourselves, we know that many APM tools fail to give meaningful data to developers, making debugging and troubleshooting time-consuming. What’s more, current pricing models make traditional APM tools inaccessible to companies operating in modern development environments.

We built Raygun’s APM from the ground up with these problems top of mind, which is why we can say that we are different. Raygun is a developer-friendly product that excels in delivering the necessary details needed to fix problems quickly, without the heavy restrictions traditional tools carry.

Our latest support for Ruby also reflects that.

“With our previous APM tool, we struggled to correlate the problem to cause. Raygun APM doesn’t just tell you what is slow, it tells you why.”

Vidar Sømme, Chief Development Officer, Vetserve

Find and solve Ruby performance problems fast

Raygun APM delivers more code-level detail with our flame chart

We’ve put a lot of thought into how developers will use this every day. We know that when there’s a lot of data flowing, charts can get overwhelming and it can be difficult to discover, prioritize, and resolve issues.

When you’re in the discovery phase, the customizable Overview page visualizes all the high-level data you need to spot performance trends over a certain time. Monitor Apdex score, slowest requests and methods, active issues, and more for full visibility into your application performance.

If you’re not sure where to start, our unique automatic issue creation engine curates a list of your most urgent performance issues for you, sorted by priority.

Raygun's issue detection engine helps you to prioritize and sort issues

Behind the scenes, there are many causes of poor performance, and you’ll want to find and resolve them as quickly as possible before they affect your customers. With Raygun APM, getting more actionable detail into an issue has never been easier.

The Traces page of Raygun APM is where you can find all the traces for your application so you can start to drill down into the specifics.

Clicking on an individual trace will take you to the flame chart which shows you the state of your code at every millisecond during the performance profile. This gives you a way to know exactly which function was executing at any point during the recording, how long it ran for, and where it was called from.

The flame chart allows you to visualize your code rather than just using a call tree view. Once you’ve isolated the issue, drill down into the details of the call, such as the execution time, parent percentage, duplicates, and hotpath. The detail doesn’t end there — the GitHub integration will link you to the exact line of code.

At the end of the day, Ruby developers want to build fast and efficient applications. This resolution workflow helps you deliver great work and avoid spending too much time debugging and tracking down issues.

Raygun APM is built for Ruby

Raygun APM works harmoniously with Ruby so you can optimize application performance. With this release, we’ve baked in specific features that support faster trouble-shooting for Ruby apps.

Monitor SQL queries

Raygun APM provides excellent support for filtering and drilling down into SQL performance metrics.

Keep tabs on HTTP API calls and how it affects your application

Services and applications, especially in modern cloud computing paradigms and microservices oriented deployments, coexist with others. The Raygun APM platform has great support for tracking and creating rules for external HTTP API calls.

Support for tracing Sidekiq background jobs

Sidekiq uses threads to handle many jobs at the same time in the same process. Discover performance problems in Sidekiq threads quickly.

Support for Heroku with a Buildpack

Raygun APM offers seamless integration with the Heroku platform via a Buildpack, so you can get all the benefits of APM for your Rails app.

Reduced overhead

We built APM using a fast communication protocol and optimized code to reduce the profiling overhead. This allows us to emit detailed trace information for Ruby apps with a low-performance impact.

While these features help to get granular into performance problems, how do you know if they have made an impact on the real people using your website? Our Real User Monitoring (RUM) solution enabled alongside APM answers these questions and more.

Understand how server-side performance impacts users with APM and RUM

With Raygun APM, you can combine server-side timings with front-end performance data from RUM to get a complete view of your user experience. Once you integrate with RUM for a small additional fee, you won’t be left trying to manually correlate user data between tools, and you’ll be able to assign dev resources to where it matters the most.

In the video below, you can see that Raygun APM detected a problem. Watch how you can click through to Real User Monitoring to see the performance breakdown of the page, including the server percentage of load time.

With Real User Monitoring and APM enabled, get user-level detail for server performance problems

Accessible pricing for modern development teams

Raygun offers sophisticated yet cost-effective application performance monitoring across the whole stack, no matter if you are using microservices or monolithic architectures. Our usage-based pricing starts at just $8 per month.

Integrations available on release

Raygun APM for Ruby works with your current development environment and already has all of the features you need to diagnose issues quickly. Slack, Jira, and GitHub integrations are all available today, with more being released soon.

Slack

Report issues directly into a specific channel where you can assign, ignore, or resolve issues directly in Slack. Advanced filtering makes sure you are only alerted to the issues that matter.

Jira Software

There’s no need to copy-paste contextual information about errors into tickets in Jira. Create a new issue or add information to an existing issue in just a couple of clicks. All the information you and your team need to resolve the error will appear on the ticket.

GitHub

Raygun's source code integration with GitHub links the diagnostic details captured to the source code in your GitHub repository for faster resolution.

If you'd like to read more about our integrations, you can head to our documentation.

How to get set up with Raygun APM for Ruby

It’s easy to get started with our lightweight agent. Simply take a free 14-day trial today.

Here are some quick links for getting set up.

You can find all the below instructions in the Getting Started documentation:

If you need any additional help getting set up, contact our team here.

Raygun’s latest support for Ruby provides end-to-end monitoring capabilities across your entire tech stack. We provide more detail and better data visualization than any solution on the market today. Thanks to our usage-based pricing, you’ll get sophisticated Ruby performance monitoring for a great price, no matter what your architecture looks like.

Raygun APM is currently available for Ruby, .NET, Azure App Service, and .NET Core, but watch this space for Node.js, Java, and more. Request to be notified when your language becomes available.

Keeping Netflix reliable, tech leaders' views on customer experience, and the Advent of Code

Raygun Staff — Thu, 26 Nov 2020 22:00:53 +0000

Hi folks,

Welcome back to Performance Matters. This time, we're proud to bring you the recording from our live Tech Leaders event. With Raygun's CEO John-Daniel Trask at the helm, the conversation brought together a wealth of insights into how to prioritize the customer during design and development.

Read on for the latest engineering article from Netflix, the t-shirt inspired by 40ms of latency, and the holiday challenge Avent of Code is almost here.

Enjoy!

Your Curator

FEATURED ARTICLES

How tech leaders are prioritizing customer experience

In today’s climate, companies are faced with many challenges. But one thing should remain the same — the focus on delivering value to the customer. Raygun's latest Tech Leaders' Panel brought this sentiment front-and-center.

Read the highlights and watch the full panel

Keeping Netflix reliable

The Netflix engineering team share how they build a more resilient system with load shedding.

Read the breakdown

40 milliseconds of latency

Rachelbythebay recalls no matter what the team tried, 40 milliseconds of latency remained.

See where it was found

BUG OF THE WEEK

Hacking Apple

A white-hat hacker team of 20-year olds spent three months hacking into Apple. They found 55 vulnerabilities, 11 of them critical, potentially earning the team half a million dollars.

Read the overview

The large-scale AWS outage

At the time of writing this edition of Performance Matters, AWS is currently having an outage, taking a portion of the internet down with it.

View the status page

COMMUNITY

The Advent of Code is here

A fun and collaborative project for you and your team to get involved in is the Advent of Code challenge. A new coding challenge unlocks every day from December 1st.

Join in and create a leaderboard

If you think Performance Matters is pretty great, why not sign up to receive it in your inbox every week? 🙌

APM workflows, performance and emotion, and PS5 crashing Walmart's website

Raygun Staff — Thu, 19 Nov 2020 21:15:17 +0000

Hey folks,

Welcome back to yet another edition of Performance Matters, your hub for software performance tips, tricks, and news.

Do you feel as though you have an effective APM workflow? Well, this week we're digging deep and providing 3 powerful workflows that you can use with Raygun. We'll also be looking into how emotion and performance are correlated, the PS5 launch taking down Walmart's website and more.

Enjoy!

Your Curator

FEATURED ARTICLES

How to build 3 powerful APM workflows with Raygun

There are many ways we can approach improving application performance on any given day. By the end of this article, you’ll have a powerful new APM workflow at each stage of your SDLC that will help you detect, diagnose, and resolve performance problems.

Improve your workflow

Performance's impact on emotion

How does your site make users feel? Performance and emotion are more closely intertwined than you think.

Delight your users

Back/forward cache

Optimize your pages for instant loads when using the browser's back and forward buttons.

Reap the benefits

BUG OF THE WEEK

Walmart disappointed several gamers this week

With the release of the brand new PS5, it should come as no surprise that gamers flooded to retailers stocking the elusive console in record numbers. Unfortunately, Walmart's website couldn't keep up with the demand.

The power of gamers

COMMUNITY

The speed geek's favorite time of year

Passionate about a topic? Working on a new tool? Have a technique you want to teach? Research you’ve done? Tell the web performance community!

Make a contribution

The results are in!

If the Google Page Experience Update was rolling out in December 2020, how ready and optimized do you think your site(s) would be?

See what the polls say

If you think Performance Matters is pretty great, why not sign up to receive it in your inbox every week? 🙌

Search engines, speed tests, and debugging at Google

Raygun Staff — Thu, 12 Nov 2020 20:38:02 +0000

Hey folks,

Welcome back to Performance Matters 👋 This week, we're inspired by Google's announcement that page experience signals would be included in Google Search ranking from May 2021. This should come as no surprise, but it's a timely reminder to keep pushing for speed and adopting new performance metrics.

We've also released Raygun's October launch notes if you want to catch up on what we've been shipping 🚀

Enjoy!

Your Curator

FEATURED ARTICLES

Web performance and search engines

There is a lot of talk about web performance as a ranking signal in Search Engines and how important or not it is, but often people are overlooking how performance affects multiple phases of a search engine such as crawling, rendering, and indexing.

Take a look beyond ranking

Reducing variability in metrics

This article looks at three different websites and investigates how much running tests 1, 3, 5, or 7 times reduces variability.

Find your average speed

Getting fast and staying there

Getting fast is difficult, staying fast even more so. How do successful companies ensure that their site speed stays at peak?

Maintain your speed

BUG OF THE WEEK

Debugging incidents in Google's distributed systems

Learn how engineers at Google debug production issues, including the types of tools, high-level strategies, and low-level tasks that engineers use in varying combinations to debug effectively.

Google's debugging workflow

COMMUNITY

Npm's new public roadmap and feedback process

Npm is the world’s largest package registry, powering the world’s largest development community—JavaScript. Their new public roadmap and feedback process takes their collaboration with the community to a whole new level.

Npm's open lines of communication

Raygun's launch notes

Tech Leaders’ Panel, spike protection, and more. Catch up on all the updates in our monthly launch notes.

See what we've been working on

If you think Performance Matters is pretty great, why not sign up to receive it in your inbox every week? 🙌

Redefining customer experience, Ruby EC2 instances, and register for AWS re:Invent

Raygun Staff — Thu, 05 Nov 2020 20:39:04 +0000

Hi folks,

Welcome to Performance Matters. This week, we're excited to bring you the latest Tech Leaders' panel event. You won't want to miss the insights on building customer-centric software from some of the brightest minds in tech.

We've also got the latest from CSS-Tricks, an interesting case study on which EC2 instance you should use for your Rails app, and an invite to the virtual AWS re:Invent conference.

Enjoy!

Your Curator

FEATURED ARTICLES

Tech Leaders event now on YouTube

In today’s digital world, leading companies are having to redefine what it means to deliver a flawless experience for their customers. This panel discussion holds some excellent learnings from seasoned leaders and is worth a watch.

Customer experiences in today's digital world

*(Please note that in New Zealand we have no social distancing rules or mask requirements in place.)*

CSS Tricks and performance

The latest version of the popular newsletter has a strong focus on Real User Monitoring and performance.

Read the web version

The best EC2 instance type

So what type of EC2 instances should you run your Rails app on? The answer is simpler than it looks.

Read the breakdown

BUG OF THE WEEK

The software bugs that are years old, but haven't been patched

Almost two-thirds of vulnerabilities on enterprise networks involve flaws that are over two years old that have not been patched, despite fixes being available. They’re now at risk from bugs that could have been fixed years ago.

Read the article

COMMUNITY

AWS re:Invent registration is open — and it's free

Unlimited access to hundreds of sessions, this year's AWS event is not to be missed.

Check out the speakers and register here

If you think Performance Matters is pretty great, why not sign up to receive it in your inbox every week? 🙌

Optimizing WordPress & Webflow, what is RUM, and the Tech Leaders' Livestream

Raygun Staff — Thu, 29 Oct 2020 20:52:42 +0000

Hi folks,

Welcome back to Performance Matters. Next week we're excited to bring you the Tech Leaders' Panel event, live all the way from NZ. Join us, as we talk with leaders from Vend, Xero, and Lancom, about how they're putting the customer experience at the center of their development workflow.

In this edition, we're digging deep into performance optimizations on WordPress and Webflow, recapping the benefits of RUM, and looking at the real-world implications of voter registration websites crashing a week out from an election.

Enjoy!

Your Curator

FEATURED ARTICLES

What is Real User Monitoring and how can it help teams?

Real User Monitoring tools help software teams to identify front-end performance issues, measure trends in application performance, and improve the customer experience. Find out whether it's right for you.

How RUM can help

Performance optimizations to speed up your Webflow site

A handful of recent updates to Webflow that let you optimize your site for even faster performance.

Speed up Webflow

28 tips to help speed up your WordPress site

A comprehensive list of tips to help you get the best performance possible from your WordPress site.

Optimize WordPress

BUG OF THE WEEK

Registration websites are crashing, locking out would-be voters

From Florida, callers said the voter registration website had collapsed, locking them out just as the deadline for registering to vote approached.

Here's how they reacted

COMMUNITY

Monitoring what matters: Prioritizing customer experiences in today's digital world (Livestream)

In this exclusive panel discussion, you will learn how software teams at Vend, Xero, Tend Health, and Lancom put the customer experience at the center of their development workflow, closing the feedback loop between code and customer. Join us live - we'd love to see you there!

If you think Performance Matters is pretty great, why not sign up to receive it in your inbox every week? 🙌

Monitoring and Performance Wrap Up - October 2020

Raygun Staff — Thu, 29 Oct 2020 00:56:56 +0000

Hi! I'm Helen, one of your friendly mods looking after the #monitoring and #performance tags.

At the end of each month, I'll be showcasing some of the great posts, projects, and insights from the Dev community.

To kick us off this month we have James who has written their first post detailing the mechanics of each step a browser goes through to render a web page so that each can be considered and optimised during development. Welcome to Dev James!

Article No Longer Available

Next, Cody introduces us to the Observer API. There are four different types of observers that observe different things -- from the DOM to browser performance.

Article No Longer Available

Justin then shows us how to optimise using lazy loading components in Vue. A few extra seconds could have a huge impact on the number of users visiting your site. This means that having a fast site is important, not just for ranking well in Google Search Engine, but for having users interact with your webpage.

Lazy loading components in Vue 3

Justin Brooks ・ Oct 5 '20

#vue #webdev #performance

Sticking with Vue, our next post from Mariana takes us through a refactoring project. Refactors are never easy but can make a huge difference in performance. This is Mariana's first post too, welcome to Dev!

My notes about conducting a massive refactor in a Vue.js website

Mariana Pícolo ・ Oct 22 '20

#vue #frontend #architecture #performance

Next, Breno focuses on the first steps you can take to approach web performance. Great first post, welcome to Dev Breno!

5 things you need to know about web performance in 2020

Breno Henrique ・ Oct 5 '20

#webdev #performance #html #javascript

To wrap up this months posts we have a discussion from Pawel from the Dev team on lazing loading images. Are there any cons and gotchas to look out for? Check out the discussion for more.

Any reason for not using loading="lazy" attribute?

Paweł Ludwiczak for The DEV Team ・ Oct 26 '20

#html #performance #explainlikeimfive

That's all for this month! For more, check out the #monitoring and #performance tags.

The cost of QA is falling, LinkedIn's scale achievements, and taking care of the details

Raygun Staff — Mon, 26 Oct 2020 20:20:33 +0000

Hi folks,

Welcome back to Performance Matters.

In this edition, we have something for everyone. Read about how the cost of software quality could be falling, LinkedIn Engineering's deep dive on Linux filesystem performance regressions, and the virtual summit coming to your screens soon.

Enjoy!

Your Curator

FEATURED ARTICLES

A move in the right direction

The results are in: Quality assurance (QA) testing quality is going up while costs are coming down. The share of IT budget allocated to QA testing has been falling year-on-year for the last four years.

What does that mean for software teams?

Preserving software quality

From formatting code to writing docs, the mundane tasks could be the most important.

Build a culture of quality

Linux perf. regressions

LinkedIn shares a new set of learnings from refining their processes for scale.

Read the case study

BUG OF THE WEEK

The cause of Twitter's outage is still unclear

“We have no evidence of a security breach or hack, and we’re currently investigating internal causes,” a Twitter spokesperson said in a statement to The Verge.

So what happened?

COMMUNITY

DevOps Experience

Returning for its third year, DevOps Experience is back with more great stories of DevOps transformations, including talks on observability and monitoring. With speakers from Netflix, Microsoft, and more, it's worth adding to the calendar.

Get the details and see the line-up

If you think Performance Matters is pretty great, why not sign up to receive it in your inbox every week? 🙌

Business outcomes vs. performance, Heroku's struggle, and free Stanford CS courses

Raygun Staff — Thu, 15 Oct 2020 20:39:48 +0000

Hi folks,

Welcome back to Performance Matters. Thank you to everyone who has had a chance to check out our new Ruby APM! We hope you're enjoying using it as much as we enjoyed making it 🚀

Today, we're digging deep into the link between site speed and business outcomes, the performance of Ruby 3.0.0-preview1, and why Heroku's raw power is struggling to keep up.

Enjoy!

Your Curator

FEATURED ARTICLES

Strengthening the link between site speed and business outcomes

As performance advocates, we champion the idea that improving performance adds value, but improving site speed comes with a cost. We need to persuade other stakeholders to prioritize and invest in performance by showing its value.

Make the perfect pitch

How's the performance of Ruby 3.0.0–preview1?

How does the new preview's performance stack up on Rails? And how reliable are these numbers?

Let's find out

Heroku is being left in the dust when it comes to raw power

When thinking about server pricing, don't forget about single-thread performance. Slower ≠ cheaper.

See why

BUG OF THE WEEK

Microsoft’s cloud-based Azure App Services could have allowed server-side forgery requests and remote code-execution attacks

Researchers have disclosed two flaws in Microsoft’s Azure web hosting application service, App Services, which if exploited could enable an attacker to take over administrative servers.

Understand the flaws

COMMUNITY

150+ Stanford Computer Science courses available online

A compilation of over 150 Stanford on-campus computer science courses that are, to varying degrees, available online.

Start learning

Raygun's September launch notes

Raygun’s Launch Notes are your regular round-up of all the improvements we made to Raygun last month — from significant features to performance updates.

What's been happening

If you think Performance Matters is pretty great, why not sign up to receive it in your inbox every week? 🙌

Announcing Ruby APM, causal graphs at Slack, and Carole Baskin's take on AWS

Raygun Staff — Thu, 08 Oct 2020 20:42:51 +0000

Hi folks,

Welcome back to Performance Matters. This week at Raygun, we've been busy launching the general availability of Ruby APM 🙌. Read all about how we're different from other APM players, and how we are redefining what APM should be for developers.

Read on for the latest update from the Chromium blog, how Slack's senior software engineers approach debugging complex systems, and David Hasselhof, Flavor Flav, and Carole Baskin help simplify DevOps.

Enjoy!

Your Curator

FEATURED ARTICLES

Ruby APM now available in Raygun

We are thrilled to launch the next chapter in our ongoing support for Application Performance Monitoring: Ruby support for Raygun APM. Ruby teams can now get end-to-end monitoring with features like detailed trace transactions, dashboards, code execution, and more.

Read about the launch

Chrome is deploying HTTP/3 and IETF and QUIC

The latest update to Google will bring some additional performance improvements to Chrome.

Read the announcement

Tracing at Slack — Thinking in causal graphs

“Why is it slow?” is the hardest problem to debug in a complex distributed system like Slack.

Diagnosing slow channels

BUG OF THE WEEK

A Facebook bug exposed anonymous admins of pages

A bad code update allowed anyone to easily reveal which accounts posted to Facebook Pages—including celebrities and politicians—for several hours.

The unexpected bug

COMMUNITY

Celebrities explain DevOps

David Hasselhof, Flavor Flav, and Carole Baskin help simplify AWS, Kubernetes, and Docker.

Please enjoy the video thoroughly

If you think Performance Matters is pretty great, why not sign up to receive it in your inbox every week? 🙌

Shopify's Ruby monolith, common PostgreSQL bottlenecks, and Wikipedia's new look

Raygun Staff — Fri, 02 Oct 2020 02:25:51 +0000

Hi folks,

Welcome back to Performance Matters. It's been another big week here at Raygun with the launch of XHR-level detail for response codes. This latest feature is part of our journey to provide best-in-class support for single-page applications ⚡️

In this edition, we're diving deep into the state of Shopify's monolith, we have a guide to solving common PostgreSQL issues, plus why Wikipedia is getting a new look 👀

Enjoy!

Your Curator

FEATURED ARTICLES

Under deconstruction: The state of Shopify's monolith

Shopify's core monolith has over 2.8 million lines of Ruby code and 500,000 commits. Over three years ago, Shopify founded a team to investigate how to make their Rails monoliths more modular by creating smaller, independent units of code.

See the progress (and learnings)

PostgreSQL Performance Issues

Step-by-step guide on using PG Extras library to spot and resolve common PostgreSQL issues.

Read the guide

My website is slow, now what?

You built a great-looking, feature-rich website. But it also has a big problem: it’s just too slow.

What do you do?

BUG OF THE WEEK

Microsoft outage brings down Azure, Office 365, and Teams

Some users were unable to log into Microsoft's Office 365, Teams, Outlook, and other offerings for three hours late on Monday US time, due to a botched upgrade. Worryingly, the US also suffered an interruption to 911 emergency call services at the same time.

Find out what happened

COMMUNITY

Wikipedia is getting a new look for the first time in 10 years

Wikipedia has remained a critical and widely-used resource for knowledge across the world for the past two decades and it's about to get a series of improvements.

Here's why

SIGNAL 2020 – Now available on-demand

Twilio’s annual customer and developer conference brings a ton of developers and tech leaders together to help build better customer communications and experiences. This year's event has just wrapped up but now all the content is available on-demand.

Check it out

If you think Performance Matters is pretty great, why not sign up to receive it in your inbox every week? 🙌