JavaScript
Designing a Scalable Backend in Node.js
Let's examine three scaling challenges for a Node.js app and see how you can avoid them.
Elixir
Absinthe for Large Elixir Applications
Discover how you can best use Absinthe for data-heavy Elixir applications.
Ruby
How to Use Sinatra to Build a Ruby Application
Sinatra is a powerful framework for Ruby applications. Let's see it in action.
JavaScript
Set Up Tracing for a Node.js Application on AppSignal
We'll set up an example Node.js app and add tracing using AppSignal.
JavaScript
Advanced Fastify: Hooks, Middleware, and Decorators
In the second part of this series, let's dive into advanced Fastify concepts: hooks, middleware, decorators, and validation.
Elixir
Tackling Performance Issues in Ecto Applications
Let's dive into three common performance issues in Ecto applications and see how to fix them.
AppSignal
Transport Your Logs to AppSignal with Winston
Use Winston with AppSignal Logging to leverage your application's capabilities.
JavaScript
An Introduction to Async Stack Traces in Node.js
Let's dive into how async stack traces work and how they can be used to debug code.
Ruby
Manage Your Ruby Logs Like a Pro
Discover the ins and outs of logging in Ruby, including how to customize your logs and use logging libraries like Lograge.
Elixir
An Introduction to Absinthe
In the first part of this Absinthe for Elixir series, let's explore some of the basics of Absinthe and GraphQL.
Ruby
Organize Business Logic in Your Ruby on Rails Application
In the first part of this two-part series, we'll run through popular methods to organize your business logic.
JavaScript
A Guide to Handling Errors in Preact
Let's explore the methods you can use to handle Preact errors.
More articles
- Integrate and Troubleshoot Inbound Emails with Action Mailbox in Rails
- Getting Started with Fastify for Node.js
- How to Monitor Custom Metrics with AppSignal
- Test Data Libraries for Elixir
- How to Load Code in Ruby
- Node.js Pitfalls to Avoid
- Optimize Your Prisma Queries with AppSignal and OpenTelemetry
- Audit Logging in Ruby and Rails
- An Introduction to Mocking Tools for Elixir
- How to Use the rodauth-omniauth Gem in Ruby
- Monitor the Health of Your Node.js Application
- Monitor NGINX Performance Automatically with AppSignal
- Diving into Custom Exceptions in Ruby
- Debugging Phoenix LiveView with open_browser/2
- Authorization Gems in Ruby: Pundit and CanCanCan
- Introducing AppSignal Logging
- Generating Data Functions in Your Elixir App
- A Generalized User-local Container for UI State in Kredis
- How to Build an Error Handling Layer in Node.js
- Making the Most of Your Logs in Rails
- An Introduction to Test Factories and Fixtures for Elixir
- Storing Ephemeral UI State with Kredis for Rails
- Track Errors in Your NestJS Application with AppSignal
- What's New in Rails 7.1
- Introducing AppSignal for Hanami
- Under the Hood of Ecto
- An Introduction to Application Monitoring
- Puppeteer in Node.js: Common Mistakes to Avoid
- AppSignal for Elixir Now Supports Oban
- 5 Node.js Tools to Learn in 2023
- A Guide to Rails View Helpers
- Monitoring Your NestJS Application with AppSignal
- Calling Ruby Methods in C: Avoid Memory Leaks
- How To Instrument Your Elixir Application with AppSignal
- How to Parse Arguments in Your Ruby C Extension
- Secure Your AWS Lambdas with TypeScript
- Create a Business Language for a Rails Application
- Debugging and Tracing in Erlang
- AppSignal’s Top 5 Elixir posts in 2022
- AppSignal’s Top 5 Node.js posts in 2022
- AppSignal’s Top 5 Ruby posts in 2022
- A Guide to Memoization in Ruby
- How to Cache Locally in Elixir with Nebulex
- Database Performance Optimization and Scaling in Rails
- A First Look at Hanami 2 for Ruby
- AppSignal for Phoenix Version 2.2.0 Supports Phoenix 1.7
- Optimize Your AWS Lambdas with TypeScript
- Debugging in Elixir and Erlang: An Introduction
- AppSignal for Node.js 3.0 Introduces OpenTelemetry Support
- Node.js Architecture Pitfalls to Avoid
- System Notifications with Noticed and CableReady in Rails
- AppSignal's Future with OpenTelemetry
- Node.js Error Handling: Tips and Tricks
- Node.js 19 Release: What’s New
- Parser Combinators in Elixir: A Deeper Dive
- AppSignal Supports Mastodon
- How to Handle Async Code in JavaScript
- How to Scale Ruby on Rails Applications
- What's New in Next.js 13
- Sanitize Strings in Elixir with Pattern Matching and Recursion
- AWS Lambdas with TypeScript: Improve the Dev Experience
- Build a Table Editor with Trix and Turbo Frames in Rails
- AppSignal for Elixir Now Supports Finch
- Improve Code in Your Ruby Application with RubyCritic
- Parser Combinators in Elixir: Taming Semi-Structured Text
- Deploy a Node.js and MongoDB Application to Heroku
- Phoenix LiveView 0.18: New Special HTML Attributes
- Security Best Practices for Your Rails Application
- Faster XML Parsing with Elixir
- Minimize Heap Allocations in Node.js
- Debugging in Ruby with AppSignal
- How to Build AWS Lambdas with TypeScript
- Fix Process Bottlenecks with Elixir 1.14's Partition Supervisor
- Secure Your Node.js App with JSON Web Tokens
- Elixir 1.14: Better Debugging with dbg/2 and More
- JIT Compilers for Ruby and Rails: An Overview
- Benchmark Your Elixir App's Performance with Benchee
- 4 Ways to Minimize Your Dependencies in Node.js
- Monitor Ruby Application Performance with Magic Dashboards
- An Introduction to Ractors in Ruby
- Predictable Code in Elixir: Expressions as Reducers and Macros
- Build a CRUD App with Node.js and MongoDB
- A Deep Dive into Memory Leaks in Ruby
- Write a Standalone CLI Application in Elixir
- Connect a Ruby on Rails App with React in a Monolith
- All You Need to Know about EdgeDB
- Monitor Alpine Linux ARM Hosts with AppSignal
- AppSignal for Ruby Gem 3.1: MRI VM Magic Dashboard
- How to Track Down Memory Leaks in Ruby
- How to Write a Functor in Elixir
- An Introduction to Multithreading in Node.js
- Writing Predictable Elixir Code with Reducers
- Deploy Your Ruby on Rails App Using Capistrano
- How to Test Side-Effects in Node.js
- Get Started with Hotwire in Your Ruby on Rails App
- New: Nth Error per Hour/Day Notifications in AppSignal
- LiveView Assigns: Three Common Pitfalls and Their Solutions
- AppSignal’s Next Level Of Front-end Error Tracking
- State Machines in Ruby: An Introduction
- AppSignal for Phoenix 2.1: Automatic LiveView Instrumentation
- Recommended AppSignal Setup
- How to Handle Errors in React
- A Guide to Phoenix LiveView Assigns
- Add Feature Flags in Ruby on Rails with Flipper
- Adding Redis & MySQL to AppSignal for Node.js with OpenTelemetry
- Build a Data Access Layer with PostgreSQL and Node.js
- Algebraic Data Types in Elixir
- An Introduction to Polymorphism in Ruby on Rails
- Livebook for Elixir: Just What the Docs Ordered
- Using Scientist to Refactor Critical Ruby on Rails Code
- How We Improved Table Performance in AppSignal - Back-end Changes
- A Guide to Event-Driven Architecture in Elixir
- Bootstrapping with Ruby on Rails Generators and Templates
- Logbook: Team Discussion and Full Incident History
- Node.js 18 Release: What's New
- Using Profiling in Elixir to Improve Performance
- What's New in React 18
- Principles of Object-oriented Programming in TypeScript
- 5 Tips to Design Ruby on Rails Transactions the Right Way
- Phoenix LiveView Under The Hood: The Form Function Component
- Build Serverless APIs with Node.js and AWS Lambda
- The Perils of Parallel Testing in Ruby on Rails
- A Guide to Secure Elixir Package Updates
- New Process for Exception and Performance Incident Emails
- A Complete Guide to Node.js Process Management with PM2
- Import Maps Under the Hood in Rails 7
- Organize Your Custom Dashboards More Easily in AppSignal
- Patterns and Anti-patterns in Node.js
- Dependency Injection in JavaScript: Write Testable Code Easily
- Delayed Job vs. Sidekiq: Which Is Better?
- An Introduction to Deno: Is It Better than Node.js?
- Functional Programming in Elixir with Witchcraft
- How to Keep Database Table Sizes Down and Prevent Data Bloat
- Use Streams to Build High-Performing Node.js Applications
- Improvements Made to AppSignal for Node.js in 2022
- Test and Optimize Your Ruby on Rails Database Performance
- Securing Your Phoenix LiveView Apps
- How to Set Up a Node.js Project with TypeScript
- How to Migrate Your Blog from Gatsby to Next.js
- Build Interactive Phoenix LiveView UIs with Components
- Next Level Ruby on Rails Application Monitoring with AppSignal
- AppSignal’s Top 5 Elixir Posts in 2021
- AppSignal’s Top 5 JavaScript Posts in 2021
- AppSignal’s Top 5 Ruby Posts in 2021
- 8 Common Causes of Flaky Tests in Elixir
- Exporting and Sharing Graphs From AppSignal
- What's New in Rails 7
- What's New in Elixir 1.13
- Monitor Scheduler Utilization in Elixir With AppSignal
- Node.js Memory Limits - What You Should Know
- Ruby on Rails Application Monitoring with AppSignal
- Simpler Navigation in AppSignal: A Story About Refactoring Design
- Three Ways to Debug Code in Elixir
- 7 Ways to Improve Node.js Performance at Scale
- Practical Garbage Collection Tuning in Ruby
- Pitfalls of Metaprogramming in Elixir
- A Guide to Load Testing Node.js APIs with Artillery
- Designing Error Messages and a Logging Strategy in Node.js
- Authorization and Policy Scopes for Phoenix Apps
- What's New in Node.js 17
- How to Use Macros in Elixir
- Optimistic Locking in Rails REST APIs
- How to Dockerize an Existing Node.js Application
- Add More Metadata to Your Front-end JavaScript Errors in AppSignal
- How to Do Live Uploads in Phoenix LiveView
- Improved Error Tracking for Node.js in AppSignal
- Under the Hood of Macros in Elixir
- Real-Time Form Validation with Phoenix LiveView
- Improve Your Life with Long Error Messages
- How to Reduce Memory Bloat in Ruby
- What Are Atoms in Elixir and How To Monitor Them With AppSignal
- CPU Steal Time: A Crucial Metric for Cloud Servers and VMs
- How to Debug Cloudflare Workers with AppSignal
- Application Code Upgrades in Elixir
- Launching Public Status Pages for Uptime Monitoring on AppSignal
- An Introduction to Metaprogramming in Elixir
- Best Practices for Logging in Node.js
- LiveView Integration Tests in Elixir
- Exploring Asynchronous Requests in Recoil
- Responsible Monkeypatching in Ruby
- Using Supervisors to Organize Your Elixir Application
- TypeScript Compiler API: Improve API Integrations Using Code Generation
- An Introduction to Testing LiveView in Elixir
- Ruby's Hidden Gems: Bullet
- AppSignal Error Tracking 2.0
- New Feature: Line-of-code-based Error Grouping
- An Introduction to Pattern Matching in Ruby
- A Guide to Hot Code Reloading in Elixir
- How to Get Started with Prisma ORM for Node.js and PostgreSQL
- Building Aggregates in Elixir and PostgreSQL
- General Ruby on Rails Problems and Takeaways
- How to Monitor and Optimize Your Database Performance: A Practical Guide
- Adding Kubernetes Metadata to Your AppSignal Errors
- How to Test WebSocket Clients in Elixir with a Mock Server
- The Wolf Pack Tactic for Monitoring Slow APIs
- Performance, Stress, and Load Tests in Rails
- Uptime Monitoring: A One-week Project, a Decade In the Making
- Monitoring Memory Usage for Erlang and Elixir Applications
- Integrating AppSignal With Microsoft Teams
- Launching Uptime Monitoring In AppSignal
- Zero-touch SaaS Bookkeeping with Stripe and Moneybird
- Three Ways To Avoid Duplicate Sidekiq Jobs
- New Features: Heroku Errors and a Magic Dashboard
- A Quick Guide to CO2 Offsetting for Startups
- Linting Ruby Code
- Node.js's Underrated Combo: Passport and CASL
- Ruby on Rails Controller Patterns and Anti-patterns
- AppSignal Now Monitors Koa and All Your Cascading Middleware
- Exposing More Public Endpoints for Sending Metrics and Errors to AppSignal
- Engineering for Performance: Ghost Queries
- The Easiest Way to Monitor Ruby: Automatic Instrumentation
- Powerful Caching with Redis for Node.js Applications
- New Feature: Searching Through Samples in AppSignal
- Announcing AppSignal for Ruby Gem 3.0!
- Troubleshooting ActiveRecord Performance
- Using Webpacker in Your Ruby on Rails Application — a Deep Dive
- Ruby on Rails View Patterns and Anti-patterns
- Improving Node.js Application Performance With Clustering
- RBS: A New Ruby 3 Typing Language in Action
- AppSignal for Elixir Integration 2.1 Released
- How Absinthe Uses Compilation Callbacks for Schema Validation in Elixir
- Node.js Garbage Collection: Heap Statistics Magic Dashboard
- How to Use Mixins and Modules in Your Ruby on Rails Application
- Microservices Monitoring: Using Namespaces for Data Structuring
- Top 5 Elixir Blog Posts in 2020 from AppSignal
- Top 5 JavaScript Blog Posts in 2020 from AppSignal
- Top 5 Ruby Blog Posts in 2020 from AppSignal
- New Magic Dashboard for Ruby on Rails: ActionMailer
- Setting Up AppSignal Monitoring for a Ruby on Rails Application
- The Easiest Way to Monitor Node.js: Automatic Instrumentation
- Building a Multi-tenant Ruby on Rails App With Subdomains
- Fast & Curious: Find and Fix Slow Queries & API Requests
- Server-side Rendering in JavaScript: A Modern Approach
- Ruby on Rails Model Patterns and Anti-patterns
- Announcing AppSignal for Elixir 2.0
- Understanding Associations in Elixir's Ecto
- Structuring Monitoring Data in Monolithic Applications With Namespaces
- Setting Up Triggers and Alerts From Graphs in AppSignal
- Triggers in AppSignal: Already Powerful — Now Easy To Set Up 🚀
- JavaScript Internals: Garbage Collection
- AppSignal is Free for Open-Source Software & "For Good" Projects
- Capabilities of Elixir's Logger
- Launching AppSignal Monitoring for Node.js 1.0
- Exploring Node.js Async Hooks
- Monitoring Any System with StatsD and AppSignal's Standalone Agent
- The Diagnose: How Support Works at AppSignal
- Rails Concerns: To Concern Or Not To Concern
- Improved Pagerduty Integration with Detailed Alerts
- Node.js Resiliency Concepts: Recovery and Self-Healing
- Going from Consulting to SaaS
- Getting Started With Web Vitals in Next.js
- Testing the Tricky Parts of an Absinthe Application
- Identifying and Resolving a Kafka Issue With AppSignal
- Security Best Practices for Node.js
- AppSignal Ruby Gem 2.11: Active Job and Friends
- AppSignal Now Automatically Instruments Apollo for Node.js Applications
- Introduction to Ruby on Rails Patterns and Anti-patterns
- AppSignal Now Supports Redis for Node.js Out of the Box
- The State of Elixir HTTP Clients
- Node.js Resiliency Concepts: The Circuit Breaker
- Building State Machines in Elixir with Ecto
- Scaling Queue Workers Efficiently with AppSignal Metrics
- How AppSignal Monitors Their Own Kafka Brokers
- A Deep Dive Into V8
- New Feature: Add Custom Metrics For Node.js in AppSignal
- Best Practices for Background Jobs in Elixir
- Git is About Communication
- Using Service Objects in Ruby on Rails
- A Major Overhaul of AppSignal Dashboards: Powerful and Easy to Use
- New feature: PostgreSQL Magic Dashboard in AppSignal for Node.js
- Performance and N+1 Queries: Explained, Spotted, and Solved
- Building APIs With GraphQL in Your Node.js Application
- AppSignal Adds Next.js Integration - Automatically Adds Web Vitals Monitoring
- Developer Dilemmas Are Now Online
- Using Mnesia in an Elixir Application
- JavaScript Growing Pains: From 0 to 13,000 Dependencies
- New Integration: PostgreSQL Instrumented for Node.js
- Developer Dilemmas are Coming Online Soon
- Quickly Duplicate Triggers Across Apps in AppSignal
- Avoiding Memory Leaks in Node.js: Best Practices for Performance
- RailsConf 2020.2 Couch Edition
- JavaScript Error Tracking with AppSignal v1.3.0 is Here
- Configuring your Elixir Application at Runtime with Vapor
- Elixir Package 1.13: Phoenix LiveView Helpers and Updated Typespecs
- Official AppSignal Discord Integration is Here
- New AppSignal Feature: Graph Builder
- Dissecting Rails Migrations
- Ride Down Into JavaScript Dependency Hell
- The Citadel Architecture at AppSignal
- AppSignal Now Supports Node.js: Roadmap for the Coming Weeks
- Changing the Approach to Debugging in Ruby with TracePoint
- What's The Difference Between Monitoring Webhooks and Background Jobs
- How to Use gRPC in Elixir
- Facade Pattern in Rails for Performance and Maintainability
- Building Compile-time Tools With Elixir's Compiler Tracing Features
- Building a Rails App With Multiple Subdomains
- Elixir Package 1.12: Phoenix 1.5 Support & Better Channel Error Handling
- Hostname Filter for Anomaly Detection Host Triggers
- UI/UX Updates: Faster and Smoother Sample Navigation in AppSignal
- Migrating Production Data in Elixir
- Effective Profiling in Google Chrome
- How to Monitor Your Host Metrics Automatically
- Getting Started With System Tests in Rails With Minitest
- AppSignal Ruby Gem 2.10: Better Diagnose (And More)
- Monitoring the Erlang VM With AppSignal's Magic Dashboard
- How to Get Your Elixir Application Ready for CI/CD
- JavaScript Error Tracking v1.1.0
- Rails is Fast: Optimize Your View Performance
- Pros and Cons of Using structure.sql in Your Ruby on Rails Application
- Top 10 AppSignal Blog Posts in 2019
- How to Use Broadway in Your Elixir Application
- Configurable Ruby Modules: The Module Builder Pattern
- JavaScript Errors: An Exceptional History - Part II
- Caching with Elixir and ETS
- How to Read Performance Metrics in AppSignal
- Sidekiq Optimization and Monitoring
- JavaScript Errors: An Exceptional History
- Launching JavaScript Error Tracking v1.0.
- Typespecs and Behaviours in Elixir
- Introducing area charts for custom dashboards.
- How We Tracked Down an Exception Without Errors: A Detective Story
- Ruby Templating: Baking an Interpreter
- Migrate to our new Slack App!
- TL;DR: Our new logo
- Flags, Seeds and Idempotency: Database Tooling with Elixir
- The Inherited Hook Method in Ruby - and More Parenting Lessons
- New Sample Page Graphs and Navigation
- Type Checking in Ruby — Check Yo Self Before You Wreck Yo Self
- Cleaning Up Ruby Strings 13 Times Faster
- Multiplayer Go with Elixir's Registry, PubSub and dynamic supervisors
- Digging Deeper into Ruby Templating: The Parser
- Metaprogramming: From C Preprocessing to Elixir Macros
- JavaScript Iterators and Iterables
- Last week's Product Improvements (July 15th, 2019)
- Productive Procrastination for Programmers - works for Ruby and Elixir
- Building the Go Game in Elixir - Time Travel and the Ko Rule
- Brewing our own Template Lexer in Ruby
- Introducing Incident Context and Incident Notes
- Building and Playing the Go Game with Phoenix LiveView
- The Ultimate Checklist to Properly Internationalize Devise
- How We Do VAT for Our SAAS with Stripe
- Introducing our Clubhouse integration
- Inside Enumeration in Ruby
- New Magic Dashboard: Heroku Postgres
- Doing Background Work Using a Native Elixir Approach
- Up the Ancestor Chain with method_missing
- Ruby's Hidden Gems -Delegator and Forwardable
- Kafka and Ruby, a Sidekiq Lovestory
- We've got your back at RailsConf
- More personal email notification preferences
- Routing in Phoenix Umbrella Apps
- Learning by building, a Background Processing System in Ruby
- Memory Magic Dashboard
- Pinned apps
- Introducing Magic Dashboards
- Object Marshalling in Ruby
- Revamped dashboards!
- Iteration, Recursion, and Tail-call Optimization in Elixir
- Improved navigation for better feature discovery.
- Ruby's Hidden Gems, StringScanner
- Diving into Ruby's #dup and #clone
- Pouring Protocols in Elixir
- Monitoring MongoDB Replicaset Lag with AppSignal
- Introducing our Google Hangouts Chat integration
- Unraveling Classes, Instances and Metaclasses in Ruby
- Introducing our Asana integration
- An instrumental intro to GraphQL with Ruby
- Serving Plug - Building an Elixir HTTP server from scratch
- Bindings and Lexical Scope in Ruby
- Elixir package 1.9: Improved Erlang error & Container memory support
- Ruby gem 2.8 - Container memory & JRuby on Alpine Linux support
- Don't be mean: Statistical means and percentiles 101
- Fibers and Enumerators in Ruby - Turning Blocks Inside Out
- Understanding Elixir’s GenStages - Querying the Blockchain
- Testing Asynchronous Threads in Ruby
- Building a Ruby C Extension From Scratch
- The innards of a RubyGem
- Hot Code Reloading in Elixir
- ActiveRecord vs. Ecto Part Two
- Improved Navigation
- The Magic of Class-level Instance Variables
- ActiveRecord vs. Ecto Part One
- #to_s or #to_str? Explicitly casting vs. implicitly coercing types in Ruby
- How OTP Applications are structured
- Differences Between #nil?, #empty?, #blank?, and #present?
- Closures in Ruby: Blocks, Procs and Lambdas
- Push and Pub/Sub in Ruby
- Lists vs Tuples in Elixirs
- Rails Collection Caching
- Elixir package 1.8: Improvements!
- Ruby gem 2.7: Improvements and bug fixes
- Changing the Way Ruby Creates Objects
- Generating Random Numbers in Ruby
- Ruby Magic Summer Special: The Best of AppSignal Academy
- Parsing Numbers in Elixir
- JavaScript-sprinkled Rails Applications
- Elixir integration 1.7 released
- Under the Hood: “Slurping” and Streaming Files in Ruby
- AppSignal Dashboard: Live updating insights
- Custom Exceptions in Ruby
- Rebooting the Luftschiff!
- Caching counters with ActiveRecord's counter caches
- Deconstructing Elixir's GenServers
- Ruby's redo, retry and next keywords
- Ruby's magical Enumerable module
- Speeding up your app’s navigation with Turbolinks
- Ensuring execution, retrying failures and reraising exceptions in Ruby
- Elixir integration 1.6: The GDPR release!
- General Data Protection Regulation (GDPR)
- Ruby gem 2.6: The GDPR release!
- Client-side caching in Rails: conditional GET requests
- ActiveRecord performance: the N+1 queries antipattern
- Post-mortem: April 19th, 2018
- Rails' built-in cache stores: an overview
- New GitHub integration
- Rescuing exceptions in Ruby
- AppSignal UI updates
- Elixir integration 1.5 released
- Russian doll caching in Rails
- Understanding system load and load averages
- Fragment caching in Rails
- Exceptions in Ruby
- Understanding CPU statistics
- Benchmarking Ruby Code
- Inspecting data in Ruby
- Comparing host metrics
- Syntactic sugar methods in Ruby
- Ruby gem 2.5 - JRuby support!
- Debugging exceptions in Rails
- Improved host metrics and alerts
- Reading and understanding Ruby stack traces
- Track cache hits with custom metrics
- Elixir integration 1.4 released
- Ruby gem 2.4 - FreeBSD support and more exceptions!"
- Koos: keeping others off support
- Better, more and more specific notification options
- Two-factor authentication
- (Mass) Change incident status
- Introducing Anomaly detection (Beta)
- Improved Snapshots of your apps
- Supervisors: Building fault-tolerant Elixir applications
- Elixir integration 1.3 released
- A look at how Ruby interprets your code
- Improved Slack notifications
- Gem 2.3 - ActionCable!
- Concurrency Deep Dive: Event loops
- Demystifying processes in Elixir
- Gem 2.2 - Custom namespaces!
- Concurrency Deep Dive: Multi-threading
- Elixir integration 1.2 released
- Elixir integration 1.1 released
- Concurrency Deep Dive: Multi-process
- Launching AppSignal for Elixir
- Gem 2.1 released - Alpine Linux support!
- Documentation updates
- Running Rack: How Ruby HTTP servers run Rails apps
- Escaping characters in Ruby
- Learning how to become a product business
- Review active browser sessions
- Add custom markers from any graph
- Building a 30 line HTTP server in Ruby
- Custom Markers
- Gem 2.0 released 🎉
- Rescuing Exceptions in Ruby: A Primer
- Rebasing a complex branch in Git
- Introducing: A new layout for AppSignal
- Gem 1.3: Giving Sinatra some love
- How to tame your growing users table
- Introduction to Garbage Collection (Part II)
- Host metrics in samples
- Introduction to Garbage Collection (Part I)
- Monitor MongoDB (query) load with Custom Metrics
- New event timeline
- Gem 1.2: Host metrics
- Gem version 1.1
- Share the love: give 100, get 100
- Upgrading to Mongoid 5 / mongo-ruby-driver
- Mastering Concurrency
- Introducing Graph Toggles
- Stroopwafels and how to eat them
- How to use custom metrics
- Getting high on our own supply
- Shipped it: A partnership with the Ruby on Rails podcast
- Event type graphs
- AppSignal agent release
- Phabricator integration
- PagerDuty integration
- OpsGenie integration
- Five Signs to Recognize a Future Customer
- Gem version 0.11.13 released
- Custom notifications with Zapier
- Automated screenshots using Capybara and Selenium
- Padrino support
- Issue states, notification settings & interface updates
- Introducing the Intercom integration beta
- Handling VAT with Stripe: Follow up
- Introducing the JIRA beta
- Official Sinatra support
- Introducing the Zapier beta (No Official Support Since 2017)
- GitLab integration
- Gem version 0.11
- AppSignal integrates with Pivotal Tracker, GitHub & Trello
- First steps towards a new front-end architecture
- Handling VAT with Stripe
- Post-Mortem: Why our gem disabled itself
- Gem version 0.10
- Consistent API
- Flowdock integration
- Gem version 0.9
- Our response to Heartbleed
- Stroopwafels as a Service
- Set notification settings per application
- Vastly improve performance for MongoDB, Mongoid and Sidekiq
- Refactoring design
- Error, performance and deploy notifications in Slack
- We now monitor your background jobs
- Realtime graphs from MongoDB with aggregations
- AppSignal API
- Error request tagging
- AppSignal and Shelly Cloud partner up
- Improved graphs and snapshots
- Taming our MongoDB database size.
- AppSignal Sunday
- Poor man's usability testing
- Developers and designers: an arranged marriage.
- Gem version 0.6
- A quick post about reducing MongoDB queries
- User test
- Designing AppSignal
- Opening up shop
- 401: Unauthorized
- Filtering sensitive data from params
- Better graphs, event tree & new hosts section
- jQuery toggle() is slow, JavaScript to the rescue
- Welcome to AppSignal!
AppSignal monitors your apps
AppSignal provides insights for Ruby, Rails, Elixir, Phoenix, Node.js, Express and many other frameworks and libraries. We are located in beautiful Amsterdam. We love stroopwafels. If you do too, let us know. We might send you some!
