SpO₂ is oxygen saturation and is used in medical person monitoring.

I am Kerollmops, I am the CTO of [Meili](https://meilisearch.com.cn/) and today I am releasing [SpO₂](https://github.com/Kerollmops/spo2/).

At Meili, we needed a tool that allows us to monitor our pods, we already have [vigil](https://github.com/valeriansaliou/vigil) which health checks our front page and backend, but the number of these services is limited. We do not pop new front or backend servers dynamically (for now). When we create new search engines for the user we instanciate a kubernetes pod, we need to monitor the health of this service. Adding each of those URLs by hand in the vigil config file is not a solution.

So we decided that we needed a simple tool, a tool that can accept HTTP requests to register/unregister URLs to health check. We use the [new async/await Rust syntax](https://blog.rust-lang.net.cn/2019/09/30/Async-await-hits-beta.html) along with [tide](https://github.com/http-rs/tide) for the http server, no big deal here.

Our current cloud provider is [Digital Ocean](https://www.digitalocean.com/), therefore, we cannot host our SpO₂ service there. We chose [Scaleway](https://www.scaleway.com) as it is way cheaper, and it works out of the box. We need persitent storage of the health checked URLs. What would you do if those are only stored in RAM? What if the server restarts? I already worked on [a disk backed key-value store in Rust named Sled](https://sled.rs/). So we chose to rely on it.

![](https://unable-actionable-car.media.strapiapp.com/screenshot_d586f10f06.png)

[@qdequele](https://quentin.llmops.com) built the front-end with vanilla javascript. Using Websocket we are able to display in realtime the pods status. As most humans do not stand in front of a TV the whole day, spotting color changes to notify the devops, we decided to implement notifications. We are using Slack for all of our monitoring tools, and because it is as simple as a webhook to implement, we went with it.

In the last release, we made some improvements to the Slack notification system. We now batch status changes events by 40; this means that SpO₂ sends one message with at most 40 events and regulates channel spamming. It also displays the HTTP status related to an unhealthy measurement and the error message on an unreachable one.

SpO₂ does not support SSL/TLS by itself, neither for the HTTP nor the WebSocket endpoints. We needed this kind of security so we looked at NGINX, a tiny little obscure reverse proxy server which we configured with basic authentication. It is not an easy task and because we are cool we made the documentation to help you do the same.

Do not hesitate to share or star this project, pull requests are welcome 😊

And just as a side note, we do not measure humans but machines actually.

SpO₂ the little dynamic monitoring tool

We want to share our thoughts about open source and how we should license our code. This is entirely new to us, and we are still figuring out the best solution and opportunities so if you have any reading recommendation do not hesitate to tell us.

As a quick reminder: at Meili, we are building [an instant search engine](https://github.com/meilisearch/MeiliDB), in Rust 🦀, and we want to open source it. We are still wondering about the right business plan for us, and we may write about it too but the subject of the day is license!

Why did we choose to go open source?
------------------------------------

We believe that every application deserves a decent search engine. That means that search engine technology should become a commodity. We found a sweet spot between Algolia which is very developer-friendly but proprietary and Elastic Search which is difficult to set up for an instant search.
  
We think that if you want to become the standard technology in your field, you should be open source, that way you get to build your features with the people who use it and you gain trust around your code. Also, because we are cool developers, we are using a lot of open source code, and we want to give back by contributing to open source and also sharing our projects.

What is open source?
--------------------

Open source is complicated, and if you ask two persons a definition of open source, you may realize that there are many definitions of open source. [Steve Klabnik wrote a very interesting blog post](https://words.steveklabnik.com/the-culture-war-at-the-heart-of-open-source) about the culture war at the heart of open source in which we learned about open source history and why people are fighting over its definition.

In the beginning, there was the Free Software Foundation, which was created in 1985. The FSF was founded by Richard Stallman to support the GNU Project and the concept of Free Software: the idea that software should be free to use, free to copy it and free to redistribute it. However, the term Free is very restrictive. For the FSF, a Free Software must be under a copyleft license. Copyleft implies that all the work deriving from it must also be copyleft. We call this a “hereditary” or “contaminating” license, and we quickly understand that this kind of license could scare businesses.

Then there was the Open Source Initiative, a non-profit organization created in 1998. Eric S. Raymond and Bruce Perens wrote the Open Source Definition which frames less restrictive licenses (MIT, Apache, BSDs, etc.). These licenses all require to credit the author of the software you are using, but what you are building can have any other license. One of the goals of this Open Source Definition was to be more "business-friendly" because the term "Free" could scare companies, and by having a more friendly name and less restrictive licenses you can encourage companies to invest and participate in open source.

* * *

To illustrate the differences, we can take two OS based on Unix: On one side there is the Linux kernel which is licensed under the GPLv2 (copyleft), and this is why Linux-based Android is open source. On the other hand, there is Berkely Software Distribution (BSD) which is licensed under the BSD license, and its most famous fork are iOS and Mac OS which are proprietary and private.

These are today's definitions of open source, and the problems are:

*   Everyone does not agree on one definition because everyone has its ideology of open source
*   Everyone does not play by the same rules: while some companies are releasing their GPL's licensed projects on some obscure FTP, others are releasing their code publicly on GitHub without an OSI approved license. What is open source to you?

Open source nowadays
--------------------

As you may have read in the last months, some "open source" projects changed their license for the same reasons. We think that [MongoDB explains it very well](https://mongodb.ac.cn/licensing/server-side-public-license/faq#what-we-sell):

> This is a time of incredible opportunity for open source projects, with the potential to foster a new wave of great open source server-side software. The reality, however, is that once an open source project becomes interesting, it is too easy for large cloud vendors to capture all the value but contribute nothing back to the community.

And they are not the only project worrying about this situation.

Redis, for example, [is licensing some of its Redis Modules under its own license](https://redislabs.com/blog/redis-labs-modules-license-changes/), the Redis Source Available License. They were previously using the Commons Clause over an Apache license. The Commons Clause adds some restriction on commercial distribution over an already existing license like the Apache one. But [they changed it for confusion reason](https://www.zdnet.com/article/redis-labs-drops-commons-clause-for-a-new-license/); people were not sure whether it was open source or not.

[Confluent changed its license too](https://www.confluent.io/blog/license-changes-confluent-platform), from Apache they choose to create the Confluent Community License because they were afraid of some big cloud companies too.

Open source and Meili
---------------------

The point is not about whether big companies should contribute more or differently to open source but that open source is evolving, and we need a new definition, a new term to gather around and know what we are talking about.

Maybe we need labels to define and frame the ideology we are supporting as a company? Perhaps we need a patent-style system which states that every code that you release as a company will be under the MIT License or any other license 3 years after you wrote it. This way you could monetize your code for a period while enabling public disclosure of your code?

At Meili, we do not have a clear vision on these issues yet, but we are thinking about it a lot. We want our code to be available to anyone, free to use it and modify it for your projects. If you're going to use it for some personal project, go for it, if you want to use it for your company you should too. We do not wish to any cloud provider to git clone our project and be a competitor on a SaaS offering. Because we believe that our project will thrive more if we can build a sustainable business on it.

Today [our code is still under the MIT license](https://github.com/meilisearch/MeiliDB/blob/master/LICENSE), but tomorrow we might change it for the Commons Clause or write our public license as MongoDB and Confluent did. No, it won't be open source as the OSI state it, but we believe that making a publicly available source code is still better than closed source, too bad there is not a clear term of it today.

Open source or not?

Today we are releasing [MeiliES](https://github.com/meilisearch/MeiliES), our event store which is fully implemented in Rust.

Event sourcing is a way to _"Capture all changes to an application state as a sequence of events"_ as [Martin Fowler describes it](https://martinfowler.com.cn/eaaDev/EventSourcing.html). The first purpose of the server is to publish events of a stream to subscribed clients. A client can also specify from which event number it wants to read, therefore it is possible to recover from a crash by rebuilding a state with new events only.

Since [a message queue is not made for event-sourcing](https://medium.com/serialized-io/apache-kafka-is-not-for-event-sourcing-81735c3cf5c), there are few available applications for event sourcing: the main option being [EventStore](https://eventstore.org/), an event sourcing database made in C#.  
So we began using EventStore for our event sourcing needs and ran against some troubles:

*   Portability: EventStore is built with C# and uses mono, making it quite difficult to install and run on UNIX
*   Support: We asked for information about EventStore commercial support and never got any response
*   Stability: the Rust client is not production-ready, and despite making some merge-requests there was still a lot to do while many of the available features were not useful to us.

So we decided to implement our own event store to resolve these issues.

MeiliES is an _Event Sourcing database_ that uses the _RESP_ (REdis Serialization Protocol) to communicate. We use the Redis protocol to simplify clients implementation. The portability problematics are resolved by using a full Rust implementation (we are using [Sled as internal storage](https://github.com/spacejam/sled)).

Installation is as simple as doing a `cargo build --release`. If you do not want to clone the repository you can [download the binaries from the Azure pipeline](https://dev.azure.com/thomas0884/thomas/_build) or run it using docker `docker run -p 6480:6480 --rm getmeili/meilies:latest`.

If you have any questions regarding MeiliES, you can tweet [@meilisearch](https://twitter.com/meilisearch) or make an [issue on GitHub](https://github.com/meilisearch/MeiliES) 🎉

MeiliES - Event sourcing in Rust

It is never easy to start a blog, we never know what to say on the first blog post 😱 so I will keep it simple here.

We are Meili, a team of three developers. In our previous job we worked on building a search engine aiming for the best end-user experience.

The most common alternatives were Algolia or ElasticSearch. Where the first one is only available as a service, you hand over your data and could be expensive. The second one is overkill for a simple end-user search,  complicated to setup and configure.

So here came our idea to develop [an open source alternative](https://github.com/meilisearch/MeiliDB) to Algolia, easy to setup, lightweight and fast.

So...

...Welcome on our blog! 🎉

I expect we will use it as often as possible to talk about what we build, company news and various thoughts.

  
(I just hope I won't be the only reader of this blog 🤭)

Meilisearch 最新消息和公司动态

SpO₂，小巧的动态监控工具

开源还是不开源？

MeiliES - Rust 中的事件溯源

开启我们的博客