Skylight Blog

Hey, thanks for the follow-up. While traffic on the marketing website has decreased since launch, traffic on the main app has increased. I do some performance monitoring (using https://skylight.io) and have identified some opportunities for speed-up. I'm working on getting those updated. I also just resized the database - it seems that some read queries were being slow. I'm continuing to dig into the postgres settings and indexes to make sure everything is good, too. -- Update: I'm seeing ~300ms responses on each of those endpoints now in my browser.

> I agree, New Relic's pricing model is almost too "enterprise". That was also my conclusion, if you look at the list of companies that uses them you will get a list of some very big businesses. And they can probably afford it, which is good for NewRelic. > I know there's plenty of ways to replicate New Relic, but who has the time? You could probably use their software, and build a collector for the data, but that doesn't really solve the issue of not building an alternative service. Yehuda Katz have built Skylight (https://www.skylight.io/) for Ruby performance metrics and they do charge for the number of requests, the platform isn't there yet, but they are improving a lot. Their newsletters are a good read :-)

A similar product is https://skylight.io, built by some very formidable people (only a Ruby apps yet though). https://serverdensity.io is another great product! I don't want to take the spotlight away from Amon here, it looks like a good product and the idea of focusing on meaningful analysis is nice (instead of only storing droves of raw stats).

It's pretty stable at this point (1.x means that no backwards compatibility will be lost as in the past), and it's already used in production (e.g. Skylight [0] is written in Rust, as far as I know, and don't forget about Servo). Dependency management with Cargo is hands down one of the best out there, it just works. The standard library continues to expand, but there are also many other external libraries you can find on crates.io. > it looks pretty functional... is it basically a systems-ish scala? I think it's better to compare Rust to ML languages family (OCaml, F#, and so on), as it was clearly influenced by it. It has many features you can find in ML languages - pattern matching, ADTs (algebraic types that are enums in Rust), and many other similarities. Overall, the language feels very robust now, and I enjoy it much - it's a very decent replacement for C++, basically "C/C++ done right". [0] https://www.skylight.io/

For what it's worth, I've been using Rust for over a year in my product (http://skylight.io) and it matched my needs pretty closely. Our product is a performance monitoring tool that runs inside of Rails apps, so it's important to us to keep the overhead of our "agent" small and controllable. Since the agent runs inside of a Ruby program, our only good choices are Ruby itself or a language without a garbage collector (embedding a language with a GC inside a language with GC is asking for trouble -- take a look at the bug tracker for TheRubyRacer for some color). Our initial version of the agent was written in Ruby, but carefully controlling memory usage or performance in Ruby isn't really feasible. We prototyped a new version of the agent in C++, but I personally didn't feel comfortable shipping a binary that would run in thousands of customers' Rails apps in a language that could segfault if you're not careful. We took Rust very seriously last November, even thought it was still very young, because it gave us a language with direct control over memory with compiler-verified guarantees that our program wouldn't segfault. TLDR: Rust is a very good choice for writing performance or memory-critical code that will be embedded in a high-level-language. Also, because it offers compile-time guarantees about safety, I expect it to expand the number of cases where people feel justified in embedding a low-level language for performance-critical problems.

We've been using Rust in production for Skylight (https://www.skylight.io) for many months now, and we've been very happy with it. Being one of the first to deploy a new programming language into production is scary, and keeping up with the rapid changes was painful at times, but I'm extremely impressed with the Rust team's dedication to simplifying the language. It's much easier to pick up today than it was 6 months ago. The biggest win for us is how low-resource the compiled binaries are. Skylight relies on running an agent that collects performance information from our customers' Rails apps (à la New Relic, if you're more familiar with that). Previously, we wrote the agent in Ruby, because it was interacting with Ruby code and we were familiar with the language. However, Ruby's memory and CPU performance are not great, especially in long-running processes like ours. What's awesome about Rust is that it combines low-level performance with high-level memory safety. We end up being able to do many more stack allocations, with less memory fragmentation and more predictable performance, while never having to worry about segfaults. Put succinctly, we get the memory safety of a GCed language with the performance of a low-level language like C. Given that we need to run inside other people's processes, the combination of these guarantees is extremely powerful. Because Rust is so low-level, and makes guarantees about how memory is laid out (unlike e.g. Go), we can build…

My turtle stack is pretty well documented and 95%+ of problems have already been solved by other people. For everything else, I'm quite happy with https://sentry.io and https://www.skylight.io for my troubleshooting needs.

* https://www.sendinblue.com/ (like Mailchimp, but easier) * https://logz.io/ (log aggregation FTW) * https://www.skylight.io/ (application performance monitoring for Ruby, similar to New Relic, written in Rust)

Have you heard about Helix? - http://blog.skylight.io/introducing-helix/ I think this is a great way to introduce large existing Ruby codebases to Rust in increments, much like Sentry demonstrated recently, but for Python: https://blog.sentry.io/2016/10/19/fixing-python-performance-with-rust.…

Skylight[0] I believe uses rust to monitor rails apps. [0] https://www.skylight.io

Skylight[1] from what I understand is a ruby gem written in Rust. It monitors your ruby runtime and sends the data to the central servers for analysis. 1: https://www.skylight.io/

MaidSafe (http://maidsafe.net) and Skylight (https://skylight.io) are both written in Rust, Maidsafe having recently moved to it from C++.

One of the first production deployments of Rust is such an application: https://www.skylight.io/ Their Ruby gem is actually written in Rust.

Since it's not very stable yet, production use is actively discouraged. I do know Tilde is using Rust for Skylight (http://skylight.io), but I don't know how far from production they are.

Actually, despite our semi-sincere objections, there are places using Rust in production. The two I know of are OpenDNS and Skylight: http://www.opendns.com/ https://www.skylight.io/

What's going on here is a bit of shorthand. If you don't use the shorthand, the signature looks like: fn access<'a, T: Send>(guard: &'a mut MutexGuard<T>) -> &'a mut T; This says that the incoming borrow and the returned borrows have identical scopes (officially called "lifetimes" in Rust; 'a here is a lifetime variable.) It's a very typical pattern: if you return some borrowed data, it generally comes from a borrow you were given, and the shorthand allows you to leave this implicit in cases where it's clear. EDIT FOR CLARITY: in particular, you're saying that if you take a "sublease" from something you've already borrowed, that sublease is valid for no longer than the original lease. So for example if you borrow a field out of a borrowed structure, the access to the field can last no longer than you had access to the original structure. In this case, we're saying that access to the data lasts no longer than the lock is held. I'd recommend http://blog.skylight.io/rust-means-never-having-to-close-a-socket/ if you want to get a bit more of a feel for how this works. The details about the shorthand are here: https://github.com/rust-lang/rfcs/pull/141

The interesting thing about Rust, is that the manual memory management actually feels a lot like automatic memory management, moreover it applies to any resource[1], not just memory, (unlike in a GC'ed language) 1 - http://blog.skylight.io/rust-means-never-having-to-close-a-socket

I remember Skylight.io did something similar with Ruby. Edit: http://blog.skylight.io/introducing-helix/

*JRuby A lot of good things going on in this space like Helix (http://blog.skylight.io/introducing-helix/) The concept of using Ruby with external optimisations using Rust or whatever feels a lot like C with inline ASM - really like where it's going

Articles like this one, and the recent project on libraries like Helix http://blog.skylight.io/introducing-helix/ make me awfully tempted to rewrite inner loops in certain production Ruby projects in Rust.

I agree. I personally found these two blog posts to be useful introductions to ownership and borrowing: http://blog.skylight.io/rust-means-never-having-to-close-a-socket/ http://arthurtw.github.io/2014/11/30/rust-borrow-lifetimes.html

I think they are referring to this http://blog.skylight.io/bending-the-curve-writing-safe-fast-native-gem… in the blogpost

Another alternative using Rust... http://blog.skylight.io/bending-the-curve-writing-safe-fast-native-gem…

We used to do this in Rust, but have found RAII much better for this. Dealing with multiple resources open at once can quickly become painful. See http://blog.skylight.io/rust-means-never-having-to-close-a-socket/#fac…

Rust's ownership model does more than just allow avoiding a garbage collector. It allows managing arbitrary resources more easily, so it is clear who is control of things at any point of time, e.g. if a function takes a File, who should close it (if the callee closes it, or if the caller needs to) is just a matter of documentation, while it is expressed naturally in the Rust type signature, and is hence checked by compilers. This isn't unique to Rust, e.g. it's basically the same as C++'s RAII but it is checked far more precisely by the Rust compiler: it is up to the programmer to not make a mistake in C++. http://blog.skylight.io/rust-means-never-having-to-close-a-socket/ It is also an important part about getting guarantees for concurrent code, as it allows fairly precise control over sharing (or not). This not only means Rust code without `unsafe` is free from data races, but also means that, for example, one can be sure a program built on message passing (ala CSP/Go) is not accidentally sharing things that shouldn't be shared. http://blog.rust-lang.org/2015/04/10/Fearless-Concurrency.html