Introducing Boundary Notifications

Posted by on July 21st, 2014

Co-authored with Ann Kilzer

Today, we’re excited to announce that Boundary’s new notification features are available to all customers. With notifications you can set up rules to automatically be notified when specific types of events occur. You can receive notification messages via email, SMS or voice calls. You can also integrate notifications with third-party systems like PagerDuty.

Below is a short overview of notifications to help you get started.

Step 1: Configure your contact information

First, you need to configure your contact details. The user settings page allows you to specify how and when you’d like to receive notifications. You can enter multiple email addresses and phone numbers and specify how long to wait before being notified. Each user can configure their own contact rules based on their preferences.

Notifications Image 1a

Step 2: Create a team

Teams represent a group of people that you want to notify when a notification is sent. Typically, teams represent a group with a shared area of expertise. For instance, at Boundary we have a team called “Operations” that includes all the engineers who maintain our infrastructure. You can create as many teams as you want and users may be a member of multiple teams.

Notifications Image 2a


Notifications Team

Boundary also includes a default team named “Everyone.” As the name implies, the Everyone Team always includes all users in your Boundary Organization.

Step 3: Create a Notification Action

Notification Actions allow you to configure what happens when a...

Continue reading Introducing Boundary Notifications  >>>


Erlang MapReduce Queries, MultiFetch and Network Latency with Riak

Posted by on June 25th, 2014

I know, you’re looking at your calendar, let me be the first to assure you it’s not 2011. I recently had the need to write some Erlang MapReduce queries for Riak and it was a bit of an adventure. The Riak MapReduce documentation is good but generally focused on JavaScript. If you’re using Riak it’s quite possible you’ve never had the need to use its’ MapReduce capabilities. We haven’t really used it at Boundary before I dug into some performance problems and it’s probably not regarded as one of Riak’s strengths. With that said though it’s a nice feature and was worth some investigation.

Slow code

To provide a bit of context let me first describe the performance problem I was investigating. Boundary customers were experiencing poor response time from a service that is responsible for managing metadata for Boundary meters. The service is called Metermgr and it’s a webmachine/OTP application that relies on Riak for persistence and exposes meter metadata with a REST interface.

I noticed that as the set of meters for an organization grew there appeared to be a simple regression in a certain queries response time. For queries with as little as 200 keys response time was between 2 – 4 seconds. After taking a look at the code I was able to pinpoint the cause of the slowdown to a function called multiget_meters. Unfortunately this function didn’t multiget anything rather it iteratively fetched them one by one, oof.

Anyway, my initial thought was, “I’ll just use...

Continue reading Erlang MapReduce Queries, MultiFetch and Network Latency with Riak  >>>


Web-Scale IT – “I know it when I see it…”

Posted by on May 27th, 2014

Webscale wordle

Recently at Boundary, we’ve been talking a lot about “Web-Scale IT”.  One of the first questions we usually get is,  “What exactly is Web-Scale IT?”  Cameron Haight of Gartner first coined this term in a 2013 blog  and said,  “What is web-scale IT?  It’s our effort to describe all of the things happening at large cloud services firms such as Google, Amazon, Rackspace, Netflix, Facebook, etc., that enables them to achieve extreme levels of service delivery as compared to many of their enterprise counterparts.”

But when we answer this,  we are tempted to fall back on cliche.   In a famous opinion offered by Justice Potter Stewart in the 1964 case of Jacobellis vs. Ohio,  Stewart wrote;

“I shall not today attempt further to define the kinds of material I understand to be (pornography)…But I know it when I see it…”

That’s how we feel about Web-Scale IT, we have a hard time defining it, but we know it when we see it!

We see it when we walk into an enterprise and hear more about the cloud than the datacenter.  We see it where release cycles are measured in weeks versus quarters.  We see it when tools like Chef are used for deployment.  We see it when we are talking to the head of DevOps.  Where there are sprints but not waterfalls.  Where the team is talking about continuous deployment, provisioning instances and open source components instead of next year’s release, hardware acquisition, and packaged software. When we see these things, we know we are seeing...

Continue reading Web-Scale IT – “I know it when I see it…”  >>>

Comments Off Tweet This

A “Quantum Theory” of IT Monitoring

Posted by on May 20th, 2014


There are certain things, which are true in the quantum world, but just make no sense in our reality.  I remember in a college advanced physics course, having to calculate the likelihood that a baseball thrown at a window will pass through, emerge on the other side and leave both the ball and the window intact, due to quantum effects and tunneling.  I was astonished to see that while the odds of this happening are infinitesimally small, they are not zero.  Never mind the fact that you’d have to continuously throw the ball at the window, not accounting for breakage, for longer than the universe has existed to even have a remote chance of observing this, the odds are not zero and can be calculated.   And at the sub-atomic level, not the physical object one, this  type of behavior isn’t just common, it is expected.  This small fact has stuck with me for decades as a great illustration of how odd the quantum world truly is.

What then does that possibly have to do with IT Monitoring?  It might be a stretch, but I think the new world of applications, which we call Web-Scale, is in some ways as strange to traditional monitoring products as the world of Quantum behavior is to baseballs, windows and normal humans.

Let me explain.   In the past, we built applications that were not quite so sensitive to small changes in infrastructure performance, for two main reasons.  First, our users had very low expectations.  From batch, to time sharing, to PC networks, to early...

Continue reading A “Quantum Theory” of IT Monitoring  >>>

Comments Off Tweet This

Dynamic Tuple Performance On the JVM

Posted by on May 15th, 2014

There are lots of good things about working on the JVM, like the HotSpot JIT, operating system threads, and a parallel garbage collector. However, one limiting factor can often be the interaction between primitive types and referenced types in Java. Primitive types are the built in types that represent integral numbers, floating point numbers, and boolean yes/no values. Primitives are memory efficient: they get allocated either on the stack if they’re being used in a method, or inlined in an object when they’re declared as field members. They also wind up being fast because the JIT can often optimize their access down to a single CPU instruction. This works really well when you know what types a class will hold as its state beforehand. If, on the other hand, you don’t know what an object or array will hold at compile time the JVM forces you to box primitives. Boxing means that the primitives get wrapped in a heap allocated object, and their container will hold a reference to them. That type of overhead winds up being inefficient both in access time and memory space. Access time suffers because this type of layout breaks locality of reference. The extra allocations and garbage generated also put pressure on the JVM’s garbage collector, which can often be a cause of long pause times.

We wrote FastTuple to try and help solve this problem. FastTuple generates heterogeneous collections of primitive values and ensures as best it can that they will be laid out adjacently in...

Continue reading Dynamic Tuple Performance On the JVM  >>>

Page 1 of 48 Older Posts
Chat with Us!