Is Redlock safe? (1 hour of undistributed reading +/-[clock skew])

This is Salvatore Sanfilippo @antirez's rebuttal to Martin Kleppmann @martinkl's "How to do distributed locking", which is, in turn, a critique of the former's distributed lock algorithm for Redis, a.k.a. Redlock. Distributed systems shoptalk always generates a stir and Martin compiled a summary that at https://storify.com/martinkl/redlock-discussion, which includes this gem by Julia Evans @b0rk's "TIL: clock skew exists".

The binary search of distributed programming (10 minutes to read)

An offshoot of the item above in which Salvatore Sanfilippo @antirez is inspired to use Redis (or any other data store that satisfies two conditions), a majority and a variation on known algorithms for solving the problem of generating monotonically growing IDs.

OR How I Vim: Salvatore Sanfilippo via How I Vim @howivim

New options for GEORADIUS: STORE and STOREDIST #GEOAPI

An important addition to the upcoming GEO API that enables pagination and set operations on the search's results.

RedisLabs/geo.lua #Lua #foss

I've put together a few GEO-related helper scripts to test some ideas. This is still very much WIP (the next version is almost a complete rewrite) so any suggestions/feature/etc is welcome :) BTW, Documentation Driven Development is awesome.

Saving memory in Redis with MessagePack and Lua scripts (worth every second)

Adrien Moreau/de Montgon @adrienmo did an outstanding job with this article because it explains how to elegantly solve a seemingly complex problem in a way that that's similar to how winning the jackpot should you feel: reduce the data's footprint, minimize network traffic and prevent race conditions. And use Lua :)

Redis, put your socks on! (<1 minute to read) #HOWTO #ProTip

If you're using Redis as a local cache – that is, on the same server as your application – you should really move to using UDS (Unix Domain Socket) instead of the network stack, as demonstrated by Olav A. Mjelde @olavamjelde's numbers.

OH Ben Nadel @BenNadel > Every time I interact with #Redis, it just makes me happy. Something about the simplicity of the API – it's joyous.

gamenet/redis-memory-analyzer #Python #foss

RMA is a command line interface that examines your data in vitro and reports memory-related statistics. The idea is awesome, and Nikolay Bondarenko @misterionkell certainly knows his way around Redis' internals so the information reported is accurate as long as RMA updated with upcoming versions. I certainly feel there's a need for such tools, but since memory analysis is tightly coupled with Redis' implementation this functionality should make its way to the core… and it will :)

pampa/rutil #Go #foss

Anonymous pampa (or maybe 9eb5?) wrote a small CLI "multitool" for dumping, loading and prettifying Redis data.

Discussion: /r/redis

Redis Transactions (1.0 minute to read)

A trenchant review of Redis' transactions from Mark Paluch @mp911de. 'Nuff said.

OH Mark Paluch @mp911de > Created a text file containing string keys for all #Redis Cluster slots. Handy for testing. https://gist.github.com/mp911de/5f9890496faca01b0ff9 <- handy indeed

Simple job queue in Bash using a FIFO (8 minutes to read)

A lineup of bash scripts that use named pipes for a producer-consumer pattern, and then some, from Stefan Petrea @wsdookadr.

Buffering SQL Writes with Redis (9 minutes to read)

Sentry @getsentry's approach to data management is an example polyglot-ism: immutable BLOBs are stored in Riak whereas variables are in Postgres. At scale, however, the data comes in at high rates and while an RDBMS is a marvelous tool for querying it, locking overheads quickly become staggering… which is just where Redis was put to use (4 years ago!) as a high speed data ingestion buffer as told by David Cramer. FQ: "Only time will tell how much longer until we face new constraints, but we're confident that choosing Redis early on was the right choice"

Stack Overflow: The Architecture – 2016 Edition (6 minutes to read) #ScalePorn

I love how open @StackOverflow are with their operations and the semi-regular updates that the team gives are always a delight. The architecture/infrastructure that it takes for keeping it up is amazing consider its lean size (small is better) and the requests that it handles (big is better) – by Nick Craver @Nick_Craver.

Tutorial: Deploying a Replicated Redis Cluster on Kubernetes with Flocker #Kubernetes #Docker #Flocker #AWS #HOWTO

A mouthful title with mouthwatering content from Ryan Wallner @RyanWallner via @ClusterHQ, that is in fact an easy-to-follow (with pictures!) guide for building and operating a highly available master-slave Redis pair.

Redis Static Charge (5 min read) #NodeJS

Kyle @stockholmux tops the score (or more accurately, makes it a score) with a vigintennial post. This time, in the interest of science, Kyle refutes his own hypothesis that serving static content (i.e. files) from Redis using GETRANGE-based pseudo streaming would be faster than disk.

Building a Streaming Search Platform (12 minutes to read)

Ryan Walker on how to build Straw – a platform for near real-time search of a streaming text data. Besides code, the platform consists of Apache Kafka, Apache Storm, Elasticsearch, Lucene's Luwak & Redis for the stream's processing.

jpadilla/redisapp #MacOS #foss

"The easiest way to get started with Redis on the Mac – Just download, drag to the applications folder, and double-click"… sounds easy enough. By José Padilla @jpadilla_.

Benchmarking Message Queue Latency (14 minutes to read)

Tyler Treat @tyler_treat revisits his earlier benchmarking effort and polishes it using his lessons learned since. Besides asking "what about Disque?", this iterative process leads one to an obvious question: how do you benchmark a benchmark?

OH Javier Lozano @jglozano >
Step 1: Create table called "Redis"Step
2: Store "data" in "Redis"Step
3: Get immediate approval to use "Redis" in enterprise

#winning <- Brilliant & you get to use SEQUEL!

#TIL How does CodePen use Redis? Critical and simple use cases, backups, and config tweaks (7 minutes to read)

Christophe Limpalair @christophelimp, whom we fondly remember from previous Redis Watch issues, writes about our favorite topic from CodePen @CodePen‘s perspective. To power this uber-frontend, the two humble Redis servers are employed (one’s a slave, naturally) to buffer n’ squash snapshot updates, background job scheduling and easy-peasy voting. But all that pales when you get to the “Critical use cases” section where you learn how an expiry-based throttler/killswitch protects an Apache Solr engine during its bad times.

There’s more goodness in the article but one thing bothers us: we’ve heard that Redis is the Leatherman of Databases, and CodePen definitely strengthens that analogy. But if CodePen is the “playground for the front end web”, what does that make Redis? The best we could come up with is multi purpose playground equipment but perhaps you can make a catchier one.

6 years of commit visualized (6 years in 30 seconds)

That’s one cool viz from Salvatore Sanfilippo @antirez of 90% of commits made to Redis where “Each commit is a rectangle. The height is the number of affected lines (a logarithmic scale is used). The gray labels show release tags.” Tcl source included, naturally. We’re fascinated with data visualizations and even more so with those that are about code, so we couldn’t have agreed more with the author’s closing sentiments.

DuckDuckGo’s Redis Cheet Sheet #Sonice

So nice to have a cheat sheet at an untracked search query easy reach – by @stephaneisfeld via @duckduckhack. The actual content is slightly, ehm, stale but we couldn’t find the sources to make a pull request for updating it… ideas?

pocoproject/poco beefs up with Redis #CPP #cplusplus #oss

Definitely not your plain old stuff – the POCO here means POrtable COponents, and this project is all about cross-platform C++ libraries with a network/internet focus. We’re not that heavily into C++ nowadays but it appears that the project has a lot to offer, and even more so now that it has been added with our favorite MPPE. The change is so recent that the documentation reveals nil, but our quick src inspection reveals nothing less than the beginning of a new Redis client. That like witnessing a baby being born or watching a supernova – very exciting. Good luck to @pocoproject and leader Aleksandar Fabijanic – “Old, but not obsolete” – @0x00FA. BTW, is anyone familiar with the Boost Software License?

Use Redis Instead of Spark Streaming to Count Statistics (5 minutes to read)

Don’t let the #math scare you, the lesson’s simple and we really can’t argue with it.

shimohq/ioredis-tree #NodeJS #Lua #datastructures #tree #foss

If you know us anything about us by now, you should know that if there’s one thing that we like it is Redis. No, make that two things: Redis and data structures. Actually, there are three – Redis, data structures, Lua and trees. Wait, that’s four. Never mind. Our thanks go to Zihua Li @luinlee.

RAM Comparison #Sonice

So nice to see that Redis is used to test RAM performance as part of OpenBenchmarking.org @OpenBenchmark‘s suite.

Better tests for Redis integrations with redislite (5 minutes to read)

Newly-liberated from mocking hell, Testing Goat prophet/messenger Harry Percival @hjwp shares the one-step road to enlitenment.

drip_and_take.lua – Token Bucket algorithm implementation for Redis #Lua #foss

This one needs no introduction and comes from Jose F. Romaniello @jfroma as part of the limitd project by @auth0.

Redis Doesn’t Store Empty Sets Or Hashes (And Will Delete Empty Sets And Hashes) (3 minutes to read) #ProRedisTip

No it doesn’t. In fact, the very notion of an empty key regardless its data structure, doesn’t EXISTS in Redis :) Still, realizing this post-factum while chasing gremlins is less than desirable so you’d be better off internalizing this now. Courtesy of Ben Nadel @BenNadel.

Cache, Rails & Redis (3:59 [30s intro incl.] minutes to watch)

Hot from last week @RailsIsrael is this talk by @Yotpo‘s VP R&D Vladislav Shub @VladislavShub on what it takes to serve 270M end users, 1400K customers and 3B impressions every month. BTW, this goes to show that having your Redis in good hands (hint: Redis Labs) can also assist with your romantic endeavors. Via @Code4WD of Raphael Fogel @fogelmania.

OH Bart Guliker @Intrepidity > Slapping some redis on it.

Minuteman’s fast analytics gets to v2… and it’s about time! #Ruby #foss

A major release for an all-time favorite of ours by Bruno Aguirre @Cuervo. New features include counting and users but there’s promise for much more in the future… stay tuned.

Note: why is Minuteman an all-time favorite? Redis is about providing tools (Lethearmans, MPPEs, …) but what makes it really amazing is the stuff that people build on top of it. QED.

Post-scriptum to note: and, of course, Minuteman uses Lua :)

CodexD Demo – Redis Migration (2 minutes to watch) #Sonice

So nice to see a demo by Norman Joyner @normanjoyner of containership/codexd‘s Docker container migration awesomeness performed on a live Redis subject.

Solving Redis timeouts with a little fundamental CS (4 minutes to read)

TL;DR Redis is simple but beware of asymptotic computational complexity. This first article via @Avvo‘s engineering is from their Director of Software Development Justin Weiss @justinweiss who, AFAWK, writes about the first publicly known Redis use case in the Legal vertical.

OH Lloyd Weehuizen @lloydw > Not sure how I got by without redis, it seems to make everything so simple

The First SF Redis Meetup ([you should give it] 12 minutes to read) #Archeology

Having taken place more than 6 years ago, this isn’t exactly what you’d call news. Still, while reading Dave Jensen @djensen47‘s writeup of that meetup, I could literally imagine myself being then and there. Not really news, some things remained unchanged whereas others didn’t, but if you’re a sentimental fool like me, the community vibe will resonate strongly with you too despite all the years that have passed.

Redis cluster shard balancing (1:15 minutes to watch)

One of the improvements coming to Redis cluster is the ability to balance the shards across its nodes. After committing this feature, Salvatore Sanfilippo @antirez shows it in this short video. BTW, with today being yesterday’s tomorrow, here’s another great ASCII movie.

EverythingMe/meduza #Go #Python #foss

@EverythingMe‘s closing down is sad but the company is intent on increasing the general goodness in the world even as it folds. Besides letting go of their extremely talented team (for other companies to instantly hire), the company is also open sourcing a lot of their internal projects (for other companies to instantly start using). Medusa, by Dvir Volk @dvirsky, is one such project that is a “cross-language, cross database, loose schema NoSQL data store, with an Object Mapper for easy querying and code integration” on top of Redis – check it out even if you don’t need something quite like that right now, it is inspiring.

ListAndHash (4 minutes to read)

Martin Fowler @martinfowler‘s voice is loud in the internets and is thought provoking as usual. ListAndHash is, as the name suggests, a hybrid data structure made up of lists and hashes. As Redis has both (and IIUC the internal implementation also consists of a mix of both), would it make sense adding it to Redis? Building a ListAndHash on top of Redis’ current API shouldn’t be too hard (I’ll leave that as an exercise to you, the reader) but does it deserve a place alongside the other basic data structures? I have mixed sentiments on the subject: one the one hand, it appears useful (“common”) but on the other hand it is a tree-like nested data structure that kind of goes against the Redis spirit. A penny for your thoughts?

OH Data Mafia @datamafia > “standards before victory”. Local #Redis terminal is ALWAYS RED! #programming

reverbdotcom/migr8 #Go #foss

migr8 is a utility for doing concurrent migration of Redis databases. It comes with an introductory blog post – Introducing migr8 a Concurrent Redis Migration Utility Written in Go and a r/redis thread from Adam Enger @atom_enger, Erik Benoist @erikbenoist and Kyle Crum @kylecrum via Reverb @reverbdotcom.

bitmapist: Analytics and cohorts for Redis (4 minutes to read) #Python #foss

Every time that an analytics package gets an update is an occasion for celebration for sum of us, and this celebration is the courtesy of Amir Salihefendic @amix3k from @todoist who bumps a version to our cohort’s joy. With both popular analytics solutions for Redis getting major functionality updates within weeks of each other, can we dare to hope that the trend will last?

dboissier/nosql4idea #IDE #foss

I’m more of a CLI type of guy – I rarely do complicated development :) – but if you’ve ever used a modern IDE, then I’m sure you’re already familiar with @jetbrain‘s impressive solutions. If you’re actually using them, then this early assessment release should make you giggle with joy – a #NoSQL plugin from David Boissier @dboissier that lets you play with your Redis/MongoDB/Couchbase database in the comfort of your windowed heaven.

OH Richard Howard @rhowardiv > 12/12 will be national HyperLogLog day in honor of the delightful 12k redis implementation (http://antirez.com/news/75)

Postmortem: Server compromised due to publicly accessible Redis (0xA minutes to read)

Everybody knows that leaving an unprotected server open to the world is a bad idea, but this report from Kevin Chen @kevinchen demonstrates just how bad it really is. I found the pathology fascinating to read, but the first lesson you should take from this is always protect your servers from unauthorized access.

ZeroMQ vs Redis (6 minutes to read)

A short research into the pros and cons of each as a communication platform (for a robot net, of course).

How Azure, Web API and Redis Helped Deliver Data Faster (12 minutes to read)

A nice war story from Microsoft’s cloud that delivers the required performance using the ubiquitous answer. My favorite quote: “Because the majority of our solutions are built using the Microsoft stack, it makes sense that we leverage Microsoft SQL Server most of the time. However, the SLA requirements for this solution specified a service response time of less than 1 second per request, at a rate of about 6,000 requests per hour, on a dataset with more than 50 million records. Because traditional databases like SQL Server store data to disk and are bottlenecked by IOPS, we couldn’t guarantee that every query would pass that requirement. To further complicate the matter, the subset of data we needed to expose already belonged to a traditional database containing terabytes of unrelated data. For that reason, we began evaluating solutions that could support large datasets quickly. That’s when we discovered Redis.”

Redis 3.2 Release Candidate 1 is out! (4 minutes to read)

It could be because Redis’ development is moving towards a time-driven release cycle, but the latest release from Salvatore Sanfilippo @antirez feels like an Xmas gift to me – it is filled to the brim with goodness that we’ve been waiting for forever. The new functionality includes geospatial indexes, cluster rebalancing, Lua effects replication, an embedded Lua debugger and variadic SPOP (!!!). And while all this will certainly delight developer personas, the new version has more than enough for the operations-minded folks as well as it brings drastic improvements in performance and memory overheads of many use cases.

Because most changes have been thoroughly tested prior to the release candidate’s release, v3.2RC1 is likely to be around only for a short while. Another release candidate for the cluster’s integration with Docker and security improvements will replace it, so in all likelihood v3.2 will be production-ready early next year.

Redis 3.0.6 and 2.8.24 are out (2 minutes to read)

A minor release that includes a few fixes and backports from v3.2. Most notably, a rare crash was addressed and an integer overflow security vulnerability in Lua was fixed. The recommended upgrade urgency is MODERATE.

3 Critical Points about Security (3.14 minutes to read, an eternity in hell if you don’t) #PSA

1. Never leave an unprotected server open to the outside world
2. If your server has been compromised – burn it
3. Always read the documentation

Memory As A Service (2 minutes to read) #MaaS

I admire the work that John Matherly @achillean is doing to raise public awareness to security issues, and at least some of the recent NoSQL-security-related public debates can be attributed directly to him and the Shodan @shodanhq project. When you think about it, the only way to address security vulnerabilities is to publicly expose them since otherwise they remain exposed to potential wrongdoers. While this post is about #Memcached, the lessons apply to most databases that are publicly exposed, Redis included. This post also deserves a <3 for the creative term-coining in title.

swizzlr/swift-redis #Swift #foss

Apparently, Apple’s Swift has just become a serious server-side language :) by Swizzmas @swizzlr.

OH Sam Saffron @samsaffron > @dhh this is just a bit too much https://github.com/rails…#L28 now every Rails install requires redis, eventmacine, celluloid and faye <- Do Action Cable’s dependencies derail #Rails5?

Redis For Everything (25:59 minutes to watch)

Yaron Wittenstein @RealWittenstein from Spot.IM @spot_im gave this delightful talk at the recent R@RailsIsrael (the view from a front-row seat) – via @Code4WD/Raphael Fogel @fogelmania.

Intro to Redis part 1 (5 minutes to read)

Even if only for its opening: “I’ve recently rekindled my love for Redis…its elegance lures me for every project.” – by “code warrior”_ Zack Urben @zackurben from Form.io @form_io. I hate #cliffhangers.

Under the Hood of Redis: Strings (Reading time ~11 minutes ) #InfernalInternals

For those of us who don’t read Russian, Nikolay Bondarenko @misterionkell put up a new promising blog and the first post is a great hard core #codeporn (albeit slightly outdated ;)) dive into Redis’ internals and the magical number 56.

OR @thoughtbot “Our most frequently used NoSQL database is Redis, which we use for storing transient, high quantity read/write data” (source: http://playbook.thoughtbot.com/)

New security feature: Redis protected mode (2 minutes to read)

The unhappy outcome of Redis’ approach to security (“it’s totally insecure to let untrusted clients access the system, please protect it from the outside world yourself” [source]), its historical defaults (bind 0.0.0.0) and the non-RTFMness of most (if not all) of us is the existence of too many unprotected servers that are open to the entire world.

While newer versions bind to the loopback interface by default, this alone still isn’t quite enough to protect against accidentally leaving the door open because most deployments will override this configuration setting (Redis is, after all, a REmote [DIctionary] Server). To overcome this, protected-mode is a compromise that changes very little of the current behavior but requires twice the effort to become exposed to risks. However, since it does break existing deployments, it will not be backported to earlier versions.

ZeroBrane Studio plugin for Redis Lua Scripts (5 minutes to read + 10:27m to watch) #Lua

ZeroBrane Studio is THE Lua IDE for me: it is open source, lightweight, cross-platform, portable, rock stable and passionately maintained by Paul Kulchenko @zerobrane. It also boasts a very handy integrated debugger that now, thanks to Paul’s work and Redis Labs’ sponsorship, plays very nicely with Redis’ LDB. Check out the screencast for an introduction, or follow these steps to get to Lua debugging heaven:

1. Download, install and start an LDB-enabled Redis server (right now, that’s the release candidate for v3.2).
2. Download and install ZeroBrane Studio v1.20 or above – the project is entirely free but if you benefit from using it, please consider supporting it.
3. Get yourself the ZeroBrane Studio interpreter plugin for Redis from the ZeroBranePackage repository, aptly named redis.lua.
4. To install the plugin for all users, drop it in the packages directory of your ZeroBrane Studio installation (e.g. /opt/zbstudio/packages/), or put it in your ~/.zbstudio/packages directory to savor it alone.

OH Redsmin {Redis GUI} @redsmin > Looking for an easy way to use #Redis LUA scripting? Well, it’s now integrated in Redsmin. Next step: the debugger!

Lua scripting with Redis (8 minutes to read)

A nice example/introduction of/to Redis’ Lua from Dan Young @danoyoung, who shows how to move some crunching server-side. Useful when faced with fuzzy requirements and the need for fast prototyping, but also valid as an approach for long-term performance optimizations.

Using Redis As a Time Series Database: Why and How (14 minutes to read) #MustRead

The Why? and How? of storing and querying time series data in Redis by Josiah Carlson @dr_josiah via @InfoQ. The ideas are clearly explained and are accompanied, as per usual with the good doctor, with runnable (#Python) code to put you immediately on the right track. Find the time to internalize and assimilate this knowledge.

Disque 1.0 RC1 is out! (3 minutes to read)

About 1.1589 Sol years (or 423 days) after git init, Redis’ little brother (or is it a sister?) makes a formal debut with its first release candidate – an in-memory, distributed job queue/message broker by Salvatore Sanfilippo @antirez that supports both at-least-once as well as at-most-once message delivery semantics and makes the best attempt to keep messages order.

OH Mathias Verraes @mathiasverraes > There are only two hard problems in distributed systems: 2. Exactly-once delivery 1. Guaranteed order of messages 2. Exactly-once delivery

How we increased our click-through rates using bandits in Python and Redis (10 minutes to read)

“We want to be as real-time as possible…which gives us a convenient excuse to use Redis.” – this quote alone is convenient excuse for a reference :) Marios @papercruncher‘s explains how an ad-serving system was optimized to tackle the multi-armed bandit problem in real time.

Building Web Analytics at SpiderOak (7 minutes to read) #RealtimeAnalytics

Quentin Donnellan @qdonnellan tells how @SpiderOak decided to build their own analytics solution despite his own brother’s advice. The end result features two of Redis’ popular use cases – firstly it is an event ingestion buffer in front of #PostgreSQL, from which the data is periodically scraped and stored. Secondly, after ETLing, it stores and serves the snappy data that’s needed for the dashboards. Hey, Quentin, can you share more of the details?

danieleteti/delphiredisclient #Delphi #foss #ExoticLanguages

Daniele Teti @danieleteti made a Redis client for a language/platform that I believed (with no apparent basis) had long passed from this veil of tears. I wonder whether #TurboPascal is still used out there…

Uploading and serving images from Redis with Node.js (3 minutes to read) #NodeJS

After an hiatus, Kyle Davis @stockholmux‘s back with a short 17th post that whirls through turning Redis into imgur. Aptly opens with “With Redis, you think small”. Ends with “so many possibilities.” #CliffHanger

Understanding the Magic of Bloom Filters With Node.js & Redis (12 minutes to read) #howto

Speaking of the Davis and until Redis boasts a first-order Bloom Filter data structure, Kyle Davis @stockholmux shows how you can still magic your way with a little help from #NodeJS.

luin/medis #GUI #foss #MacOSX

Hailed by its very own author Zihua Li @luinlee as beautiful and easy-to-use, Medis @medisclient is a local MacOSX-only-but-soon™-for-Linux-and-Windows client that does look pretty and simple. Bonus points for scoping-out KEYS and the built-in JSON/MessagePack parsers, but OTOH not every one uses an Apple and the lack of cluster support leave a lot of room for improvement.

Under the Hood of Redis: Hash [Part 1] (Reading time ~10 minutes), Hash [Part 2] & List (~12 minutes)

Nikolay Bondarenko @misterionkell keeps his blog fresh with two new articles that dig deep into Redis’ data structures. If you like them #InfernalInternals or just want to broaden your understanding of Redis’ inner workings, that’s where you should [rh]ead next.

Introduction to Redis Data Structures: Hashes (5 minutes to read)

Complementing the item above, Vaibhaw Pandey @_Vaibhaw from the MongoDB hosting service MongoDirector.com @MongoDirector gives his insights about Redis’ Hashes and introduces (at least to me) another meaning the most confounding acronym CAS.

Discussion: /r/redis

AurumAS/DoubleCache #CSharp #foss

A cache aside implementation using Redis combined with an in-heap “L1” cache by Harald S. Ulriksen @hsulriksen – recommended pattern for pracachetioners regardless of their choice of language.

jonathanong/redis-cache-decorator #NodeJS #foss

And while on the topic of caching and patterns, I really appreciate the elegance in wrapping function caching and locking with decorators – by Jonathan Ong @jongleberry.

Hacking Redis To Save Money (7 minutes to read)

“Throwing Redis at all my problems” by Peter Bui @paydro from @8tracks remembers how he once forked Redis and changed it to do his bidding (namely, expiry on slaves) so he can offload an expensive operation (set intersection) from the master. Because open source, duh. AFAIR this wasn’t discussed/PRed in the community, so now that the fork is abandonware it is of little value, which is a shame. The cluster, however, alleviates the need to use slaves for horizontal scaling so nowadays instead of forking you can just shard it.

dynomite/…/dyno_redis_rss_healing.sh #Bash #foss

This effective script from @NetflixOSS‘s Dynomite “heals” fragmentation by persisting the data, restarting the instance and repeating if needed.

Redis + Celery: Reactive Computing in Django for IoT applications (17 minutes to read)

Sachin Joglekar @joglekareshwar explains the foundations that for reactive programming (#MSExcel :)) and shows how to accomplish that in #Python‘s #Django.

OH Chris LoPresto @chrislopresto > redis is fantastic. I’d serve dinner from it if I could.

jay-johnson/docker-redis-sentinel-replication-cluster & jay-johnson/docker-redis-haproxy-cluster #Docker #cluster #foss

Jay Johnson @jayphjohnson maintains two swarm flavors for a highly-available Redis deployments – w/ and w/o #HAProxy. Both flavors employ Redis Sentinel and Supervisor to watch over the Redis instances. #PretAPorter

m-gagne/socket-chat-example-using-redis #NodeJS #socketio #foss

This not-really-Azure-specific repository from Marc Gagné @marc_gagne extends the basic chat example from Socket IO @SocketIO to create its distributed equivalent. Multiple web socket servers are employed for scale and have messages relayed to them via a Redis PubSub channel.

Blog post: How to scale your web socket server (WSS) using Redis Cache

RobertDober/redis_cloud_auto_upgrade #Ruby #foss

How cool is that? Robert Dober @lab419 makes Redis Cloud upgrades from Heroku totally automagic! Our Finance department thanks thee ;)

OH John Nye @john_nye > Redis is like the Man Friday of databases. http://redis.io/commands/geoadd .

OH DB-Engines @DBEngines >

DB-Engines Ranking climbers of the month:

1. #MySQL +22.39
2. #MongoDB +7.11
3. #Redis +5.02

Caching for a Global Netflix (14 minutes to read) #CachesEverywhere

@Netflix's "EVCache is an extensively used data-caching service that provides the low-latency, high-reliability caching solution that the Netflix microservice architecture demands. It is a RAM store based on memcached, optimized for cloud use." It is designed for caching databases and memoization, but also offers strong global consistency (or eventual) and cross data center replication. The Replication message queue is handled with Apache Kafka with proxied relay clusters. By the EVCache's team: Shashi Madappa, Vu Nguyen, Scott Mansfield @sgmansfield, Sridhar Enugula, Allan Pratt and Faisal Zakaria Siddiqi @faisalzs

OH Marcos Nils @marcosnils > _After months of work #jedis 3.0 is finally released. Check it out here: https://groups.google.com/forum/#!topic/jedis_redis/VAVgyslkERo #redis @heartsavior @xetorthio_ <= big^3 congrats & a great release date :)

RedisLabs/luascript #Java #foss

A much nicer way to run scripts from #Jedis – authored by Dvir Volk @dvirsky who'd love to get your feedbacks on it. Should be merged into Jedis if you ask for my opinion ;)

Luainsider – manage your Redis Lua scripts like a pro #howto

Apropos, here's a methodology, approach and apparatus for semi-persisting and aliasing Redis Lua scripts.

itamarhaber/file2resp.sh #Bash #foss

And not apropos, a couple of weeks ago, while working with GeoJSON, I was trying to load some bulky contents to Redis. I know of at least two Bash clients, but both were too robust for my humble needs. Then came a question from the community that had pushed me to share this.

How To Persist User Sessions Without Much Effort #NodeJS #howto

Sessionization is a favorite Redis use case – some of my best friends do that! – and this one here is a good intro to the subject. By Hays Hutton @haysh of Compose @composeio, an @IBM company.

Working with Redis #Go #howto

A gentle introduction to get you Go-ing by Alex Edwards @ajmedwards.

OH Ishan Aditya @ishanaditya > Note-to-self: If Redis does ever become the bottle-neck, first check the NIC driver :P

There is something rotten in the state of geohash (3 min read)

Chapter 21, in which Kyle @stockholmux tries to make sense of the world only to realize the obvious – there is no spoon and I wouldn't trust a module whose name could be hijacked – #LEFTPAD #JustSaying

coopengo/tryton-perf-analyzer #Python #foss

If you're using the Tryton ERP project this could be useful. If not, just appreciate the ease of using Redis to monitor an application's performance including access to the primary database – by Ali Kefia @alikefia.

Serializable cross shard client-side transactions (NaN minutes to read)

Seems simple enough… I wonder if it is applicable for uhm, lets say, Redis? by Rystsov Denis @rystsov who keeps a very interesting blog.

Iterate over all keys in a Redis Cluster (5 minutes to read)

Client authors: in case you were wondering how to abstract this, Mark Paluch @mp911de did the thinking for you. BTW, Mark had recently joined @Pivotal's SpringCentral @springcentral data team, so congrats are in order around the table.

a Scaleable A/B testing backend in ~100 lines of code (and for free*) (5 minutes to read)

A nearly-instant way to collect events using just AWS' Lambda & Redis' HyperLogLog – cool & by Yoav Avner gingerlime.

Asher256/puppet-redis_cluster #Puppet #module

Install and configure multiple instances of Redis in the same node from @Asher256

tidwall/tile38 #Go #foss

"…is a geolocation data store, spatial index, and realtime geofence. It supports a variety of object types including lat/lon points, bounding boxes, XYZ tiles, Geohashes, and GeoJSON. Seems useful, definitely instructional and very reminiscent of something extremely familiar – from Josh Baker @tidwall.

OH data['mafia'] = True @datamafia > The sweet smell of #Redis. Best described as Twizzler and motor oil. #programming #LifeInTheQueue #queueLife

Nmap Development: Ncrack postgres + redis modules #Security #Trivia

So that's actually cool in two ways, the first is obvious – I mean, who doesn't want to crack Redis, right? The second nice thing has to do with Redis and Nmap in general, so if you're idle scan through Nmap's docs to figure it out. Modules courtesy of Vaggoc Deirme @edeirme.

Redis Login Utility #Security #metasploit

This one has no trivia, it is just a brute force attacker – protect yourself by following this quote from the default redis.conf configuration file:

            # Warning: since Redis is pretty fast an outside user can try up to
            # 150k passwords per second against a good box. This means that you should
            # use a very strong password otherwise it will be very easy to break.
            #
            requirepass foobared
          

OH Chris Black @ThatChrisBlack > I still can't get over how much faster Redis caching is compared to everything else I've tried.

Harnessing the Full power of Redis (PDF, 66 slides)

I had the pleasure of actually attending Daniel Magliola @dmagliola's session at El Rug @lrug – if you already know your Redis, I recommend that you keep scrolling until the part about the phone rotator use case. Good stuff.

Redis Performance Monitoring with the ELK Stack #howto

Title says it all – by Asaf Yigal @asafyigal.

Blog post: https://www.anchormen.nl/spark-redis-receiver/

Unit testing Redis Lua scripts #Lua #DotNET #howto

The one thing that always bugs me is unit testing Lua scripts – Harald S. Ulriksen @hsulriksen shows how to pull that one easily off (although you still need a Redis server to run them).

OH Redsmin {Redis GUI} @redsmin > Yes! You can now track Redis #Cluster related metrics in Redsmin! <- Simply beautiful, kudos!

Nick Craver – Stack Overflow: The Hardware – 2016 Edition (5 minutes to read) #ScalePorn

I just can't stop drooling over Stack Overflow @StackOverflow's Nick Craver @Nick_Craver posts on their stack's everything. Of course, one thing leads to another, so you may want a refresher on how Providence uses Redis to store & serve predictions <- #MachineLearning

OH Sean Porter @portertech > .@sensu will soon have proper Redis Sentinel support, making HA Redis configuration much easier. <- that's pretty, can I have some?

Redis 3.2.0 is out! (6.379 minutes to read)

After a long time in the making (and partly because of a detour in favor of the modules API) v3.2 is finally out! With Geo, BITFIELD, #Lua replication & debugging and too many more improvements to copy-paste. Also, redis-cli got a revamp and has useful command hints and its own documentation page :)

OH Happy b111 Redis! @itamarhaber > When pronounced "K-LEE" it means tool in Hebrew, and in slang it means an extremely capable person

Redis IRC logs

After the experience of doing the first development iteration of the modules API away from the public's, Lead Dev and his team have decided not to repeat that. As a result, we've moved our discussions to the #redis channel on Freenode and the Redis website now logs it.

STREAM data structure for Redis: let's design it together! #CallForAction

A suggestion by Timothy Downs @timothy_downs at IRC triggered what is snowballing towards being the 6th core Redis data structure – your opinion matters so jump into to the discussion now. HN

Pattern: weighted random selection of an element #RedisPatterns

A once-you-see-it-you-it-is-so-self-explanatory-that-you-are-ashamed-you-did-not-think-of-this-yourself addition to the documentation that I'm sure your already knew of.

Redis as a Time Series DB (1 hour and 35 minutes to listen)

In case you missed it, here's a talk that Josiah Carlson @dr_josiah gave a little while back. The slides are at http://www.slideshare.net/josiahcarlson/march-29-2016-dr-josiah-carlson-talks-about-using-redis-as-a-time-series-db.

How to Remove Duplicates in a Large Dataset Reducing Memory Requirements by 99% (probably a few minutes to read)

Probabilistic data structures, such as Bloom Filters and HyperLogLog, are extraordinary contraptions. This is just one of the many uses that they have and for more on these see immediately below.

Scalable Streaming Data Pipelines with Redis (53 slides)

A deck by Avram Lyon @ajlyon from Scopely @scopely on munching streams with Ariel – a system that relies on Redis' HyperLogLog for aggregation.

Counting Distinct Values With HyperLogLog (8 minutes +/-0.81%)

In case you need an intro/refresher to HLL, Parker Selbert @sorentwo recently wrote one over at @codeship

Leveraging Probabilistic Data Structures for Real Time Analytics with Redis Modules (exactly 39 slides)

By pure chance, here's presentation I gave on that this very same topic (albeit heavily modules-biased, naturally) earlier this week. And, coincidentally, another improbability was witnessed. #DataStructuresOfThe3rdKind

rom Indexes and Search

Josiah Carlson @dr_josiah explains how he indexes.

eleme/corvus #C #foss

A fast and lightweight Redis Cluster Proxy for Redis 3.0 – very interesting.

A long long poll ago in an AJAX call far far away (7 min to read) #NodeJS

What edition of the Redis Watch is complete w/o at least one article from Kyle @stockholmux?

Distributed Locking with Redis and Ruby #Ruby

Mike Perham @mperham, author of #Sidekiq, tests the latter's concurrent limiter.

anvaka/redis-load-scripts #NodeJS #foss

Andrei Kashcha @anvaka worked around what have been vexing many users by redirecting require to a table that his library composes. A very cool hack.

evanx/redis-scan-bash #bash #foss

The problem: "We know we must avoid redis-cli keys '*'" -> the solution: "bashrc script for redis-scan util to iterate Redis keys" by Evan Summers @evanxsummers

Simple Graph Traversals with Redis UDFs #Lua #Howto

Dunno how I misses this beauty from Sai Teja Pratap @yesTeaPea

perrin4869/redis-mdel: mdel lua command for redis clients #NodeJS #foss

… or simply use PDEL from the rxkeys Redis module ;)

RedisLabs/spark-redis v0.3 #Spark #foss

The newest version brings in support for Spark SQL, which IMO is pretty awesome. Special thanks go to Sun He @sunheehnus for making everything possible.

Redis 3.0.7 and 3.2.0-RC3 are out #NoRC2foryou

An interim release on the way to wrapping up v3.2 and some squashing of issues. The upcoming RC4 will change the cluster's API to provide better docker & NAT support and then…

OH Salvatore Sanfilippo @antirez > Latest few weeks of work for 3.2 stabilization and next RCs. When I'll be done I'll focus only on threaded Redis for some time.

OOH Yuval Adam @yuvadm > @antirez i thought redis is already fast enough™ :)

OOH inc=[src/**/*.rs] @badboy_ > Threaded Redis ahead. What a time to be alive.

Connecting Spark and Redis (5 minutes to read)

Counting words. Using Scala. With Spark. In Redis. For the win. /cc Tim Spann @PaaSDev

Dynomite with Redis on AWS – Benchmarks (~20 minutes to appreciate fully, scales almost linearly with multiple readers)

Dynomite consistently delights me and that's a masterpiece benchmark from Christos Kalantzis @chriskalan et al at @Netflix.

Examples of using Walrus, a lightweight Redis Toolkit #Python #HOWTO

Charles Leifer @coleifer ain't just sitting on a cornflake, waiting for the users to come – he writes the howto and sees how they run, goo goo g' joob.

OH Rhian Lewis @rhian_is > So glad I made the effort to rewrite http://countmycrypto.com using #redis – much better performance and reliability!

ZeroBrane Studio v1.3 is out #Lua #foss

The slickest IDE for developing and debugging Redis Lua scripts and probably for any other engine as well just got a wonderful shiny update from Paul Kulchenko @zerobrane – a highly recommended upgrade.

Indexing Columns in Redis #CSharp #UseTheSetLuke

Despite the title not making sense, this is an overview and code example of using Sets and Sorted Sets for indexing values by Najeeb Shaikh @najeebshaikh via @codeproject. For more index-spiration make sure you familiarize yourself with the new-ish Secondary indexing with Redis doc page.

dadgar/onecache #Go #foss

…is a best-effort, replicated KV store built on top of a one-hop DHT. A side project for a drop-in #memcached replacement by Alex Dadgar @adadgar.

Embeddable data storage engines catalogue, tools and materials

Cool to see two Redis-inspired engines on that list – by Dmitry Simonenko @pmwkaa.

OH alexis richardson @monadic @antirez read that as Goedel. Without which redis is incomplete.

You should revise your Redis max connections setting (4 minutes to read)

Benoit Tigeot @Benoit_Tgt provides a good drilldown into #Sidekiq's client connections requirements in a post mortem on an appaloosa.io @AppaloosaStore outage. Takeaways: 1) brilliant use of Slack's customizability for emojis, 2) connections are should be monitored like any other resource, 3) know the limits of your RaaS provider's plan and (I can't resist this last one) 4) switch to Redis Cloud – lower prices, more connections & alerting :P

twitter/rpc-perf #Rust #foss

A performance testing tool for Redis and Memcache (atm) from @Twitter with exciting existing/future ideas up its sleeve, including rate limiting, command playback & optional heatmapability.

How I built Sinklog.com (5 minutes to read)

Useful service for instantly creating a combined log stream and a pragmatic implementation by Ben Wilber @benwilber that I find very appealing. Disappointing that the server itself isn't open source though.

Could CockroachDB Ever Replace Redis? A Free Fridays Experiment (9 minutes to read)

Redis and @CockroachDB are designed for different purposes, so my answer to the question in the title would be "no". However, the Redis API and the abstractions that it exposes can be adopted practically by any data management system, which is exactly what's awesome about Matt Jibson @mjibson's experiment.

OH Clayton A Davis #clayadavis > Stages of #redis acceptance:
0. Why would I want an in-memory database?
1. I see how it's useful in this case.
2. This changes *everything*

Sidekiq Enterprise (3 minutes to read)

Congrats to Mike Perham @mperham who has just added another sibling to the Sidekiq family. Besides changes to the license and an appropriate price model, the Enterprise version boasts four new major features: rate limiting, periodic jobs, unique jobs and leader election.

Heroku, Puma, Redis, Sidekiq and Connection Limits (<1 minute to read)

A sweet little guide for figuring out how many connections you need to configure for your Sidekiq deployment on Heroku since all free Redis add-ons' tiers are stringy with their connections (excluding Redis Cloud's generous 30 connections allotment) – from Bryan Rite @bryanrite.

Getting Started with Python Eve on IBM Bluemix™ #Python #howto

Sanjay Joshi @boilerupnc shows how it easy it is to get started with Eve, the Python REST framework, on IBM Bluemix™ @IBMBluemix with two of my favorite services: MongoDB from MongoLab™ @mongolab and Redis Cloud from us.

#HibernateOGM Redis module #Java #foss

Mark Paluch @mp911de had contributed a Redis module to the Hibernate Object/Grid Mapper that Gunnar Morling @gunnarmorling will include in the next release as tech preview – your feedbacks, I'm positive, are welcome.

OH Liviu Costea @clm160 > what flush means in different contexts #hibernate and #redis :) http://stackoverflow.com/questions/30916842/redis-cache-is-flushed-periodically-without-consent <- #faceplam

Flipper: Insanely Easy Feature Flipping #Ruby #foss

In his quest to build for @GitHub a feature flag gizmo that doesn't require Redis, John Nunemaker @jnunemaker had put together an uber platform that connects to many backends (Redis among them, of course ;)).

Redis for Security Data: SecurityScorecard JVM Redis Usage #Java #slides

The slidedeck that had accompanied Tim Spann @PaaSDev's talk from SecurityScorecard @security_score at the recent Redis NYC meetup are online – not quite like being there but better than naught. More notes: http://www.mongodbdev.com/2015/08/05/redis-meetup-notes/

Running Redis as a User Daemon on OSX With Launchd #MacOS #howto

For those who need it.

AALEKH / credis #CPP #foss

A project that uses hiredis to provide Redis cluster setup and teardown – from Aalekh Nigam @_aalekh

struct time {

Simulating a slow command with Node, Redis and Lua #NodeJS #hackto

Kyle @stockholmux shows a nice trick for doing a stack latency analysis. CAUTION: don’t run blocking Lua scripts in production, unless you mean trouble.

Tick-tock: setting a timeout on a Redis call with Node.js #NodeJS #howto

Same Kyle @stockholmux, different post. If a callback is never called back is it still a callback? Philosophy aside, the reality is the sometimes you need to time out a call and this is how you Node that.

Redis Time Series #Lua #howto

Time series are quite useful but trying to fit them into Redis can be unintuitive to the uninitiated… until you read this as-usual-top-notch piece by Markus Bergholz @markuman. Pretty simple now, right?

};

struct highscalability {

Redis + Sentinel behind HAProxy #HAProxy #howto

Karl Stoney @karlstoney put down what needs to be done to make a single IP endpoint for a Redis HA set with HAProxy – simple and sweet.

Setting up Horizontal Scaling with Redis using Twemproxy, Elasticache and EC2 #twemproxy #howto

Want scalability and want to do it on your own? Head over to Iccha Sethi @IcchaSethi's post where she cracked this one for you.

getsentry / rb #Python #foss

Don't let the name fool you – rb means redis blaster and besides having the COOLEST. LOGO. EVER. it also promises to be the fastest way to talk to many Redis nodes. KABOOM! by Armin Ronacher @mitsuhiko via Sentry @getsentry

Think before you scale (3 minutes to read)

Nice to see that @ObjectRocket is now allowing their users to scale Redis, even if only up is self service. I guess they'll need to support clustering before Derek Johnson @derekjohnson70 can tell the users to stop spending time and thoughts on scaling ;)

}; // todo: use Redis Cloud or RLEC - so much simpler

Reliable Queueing in Redis: An Update (7 minutes to read)

An update (see RW#3) from Bronto Software @bronto – Tom's words are exciting but I couldn't find the code anywhere… Help?

Efficient Redis Caching Through Hashing (5 minutes to read)

This is a classic example of what makes us engineers tick – to study something we examine it, try it out, take it apart, scrutinize its parts, modify something, put it back together, repeat, lather and rinse, and not necessarily in that order. Parker Selbert @sorentwo demonstrates the meaning of Redis' intelligent caching with a lovely study of hash optimizations (bonus points for the interactive graphs :)).

Reconstructing Payloads With Lua (exactly 6:37.9 minutes to read)

Living up to his nick (at least in this issue that is), Parker Selbert @sorentwo delivers a second piece, this time about my favorite scripting language in Redis and when to use it.

OH @yburyug > @robertfriberg Will do. I’m working on an essay on the history of them from CODASYL onwards to the creation of Redis (the first GREAT nosql)

Spring Data Redis Example #Java #howto

Although it is already high summer, it is never too late for Spring. This one is an example that should quickly get you started with Spring Data – via Java Code Geeks @javacodegeeks #IRejectTheFreeEbooks

NoSQL Exploitaiton Framework – Automating Squeezing Information out of Redis Servers (6 minutes to read)

Francis Alexander @torque59 updated his framework with new modules that target innocent Redis instances in the wild with potential attack vectors. While it is important to know about these "vulnerabilities", the first and most important step in resolving any security issue is USE A PASSWORD.

About data structures in Redis #Redis #1pager

Reads like good whiskey (or maybe vodka?) and hits just the right point – awesome a-lot-of-what-you-need-know-about-Redis-data-structures-in-one-page from Morgun Ivan @proft

Writing a Redis client in pure bash, part 2

Continuation of the project (see RW#52) from Raymond Ranelli @RRanelli.

Bajix / redis-client-pool #NodeJS #foss

"A config driven redis client factory that pools" – sounds useful.

OH Andrew Newdigate @suprememoocow > The correct way to use the Redis LATENCY DOCTOR command:
`redis-cli LATENCY DOCTOR|say -v Fred` #HAL9000 <- #RedisProTip

Redis: Crystal vs Ruby vs Node vs … (2 minutes to read)

Crystal is da bomb – by Stefan Wille @stefanwille.

closeio / redis-hashring #Python #foss

Now that is really useful – one ring to bring them all and in the darkness bind them by the Close.io @closeio team.

eu90h / rackdis #Racket #foss

Now that is something that is always fun to see – a new Redis client, this time in for Racket @racketlang.

AshSingh4888 / nodejs-redis-push-notification-demo #NodeJS #foss

Unpretentious and appears to deliver the goods needed to get you started on your own chat app or similar – by Ash Singh @Ash_Singh4u

OH Hayden Jones @work_op > Saying redis is only useful for k/v is like saying Linux is only useful for libc

How to use Rails Active Job #Rails #howto

Very useful – one-stop-shop for common patterns for queuing by Leigh Halliday @leighchalliday

Cybermaxs / Redists #DotNET #foss

Maxime Lemaitre @__Cybermaxs__ built a time series library that is inspired from a timeless classic by Salvatore Sanfilippo @antirez

How to Set Up a Redis Server as a Session Handler for PHP on Ubuntu 14.04 #PHP #howto

Another useful step-by-stepper via DigitalOcean @digitalocean, this time contributed by Erika Heidi @erikaheidi

struct two_from_sorentwo {

Managing Redis Reconnections From Ruby (5 minutes to read)

The first of our weekly duo from Parker Selbert @sorentwo discusses and explores the exciting world of reconnects with #Ruby's Redis client redis-rb – TL;DR it now appears to be working properly.

Minor release sorentwo / readthis v0.8.0 #Ruby #foss

And there is also version bump to his ActiveSupport replacement that this newsletter&39;s editor had unintentionally neglected to mention until now.

};

Minor release markuman / tinywebdis v1.1 #Lua #foss

Markus Bergholz @markuman turbo charges his Redis interface server for the rest that prefers REST over RESP.

Minor release redis / hiredis v0.13.2 #C #foss

Jan-Erik Rediger @badboy_ merges and releases an update with 3 adapters and one bugfix.

Why (and how to) Redis with your MongoDB (6 minutes to read)

DJ Walker-Morgan @Codepope from Compose @composeio (previously named MongoHQ, recently becoming an @IBM company) explains how you can use Redis for counting and queuing alongside @MongoDB. While on the subject…

UPCOMING WEBINAR Why your MongoDB Needs Redis

Join me next Thursday at 10am PST for an online session about a Redis use pattern that, once seen, can't be unseen… Register at https://redislabs.com/webinars/2015-09-03-1000

Release Redis 3.0.4 and 2.8.22

This release fixes several issues found in the replication mechanism and Sentinel. While some of the manifestations may be harder to trigger, if you're using either or both, Salvatore Sanfilippo @antirez recommends an upgrade ASAP.

infernal internals About Redis Sets memory efficiency (6 minutes to read)

There are billions of Redis users out there (per Stancliff et al), but considerably less who care about what actually goes on in it's innards. If you are one of these select few, this post from Salvatore Sanfilippo @antirez is a must read. TL;DR: soon™ – less RAM, moar awesome.

WIP lazyfree

Between fixing code issues and writing blog posts one can sometimes forget that Salvatore Sanfilippo @antirez is also a developer. If one in fact did forget, one should have a look at this work-in-progress branch, which is an arduous undertaking to be lazy.

Redis Internals and Roadmap from 2.8 to 3.2 #Redis #slides

Like the post above, if you want to understand what makes the red beast tick then this one is mandatory. Lovingly written, delightfully presented and painstakingly translated from Korean to English for us foreigners by CharSyam @charsyam this is by no means a minor contribution.

infernal internals Life in a Redis Cluster: Meet and Gossip with your neighbors (5 minutes to read and 1:12 minutes to watch)

Reading the cluster's spec is nice and all but have it animated is waaay better. Luckily, Cristian Greco @cristiangreco must have thought the same when he made this #InstantClassic.

OH @rjonesx > Using gzcompress on inserting #json into #redis isn't much slower and can cut storage in half. #php <- #RedisProTip

dwyl / redis-connection #NodeJS #foss

A module that maintains a single connection to Redis that can be used from anywhere in the app and… closes it at the end! From Nelson Correia @nelsonic via dwyl @dwylhq – also check out their clever Redis primer at: https://github.com/dwyl/learn-redis – fun read!

Migrating from Resque to Sidekiq (5 minutes to read)

Ryan Loomba @RLoombs from @sharethrough shares how he moved from using the former to the latter. The gotacha? "Sidekiq is Fast".

OH @Vincent Rischmann @vrischmann > Dear god http://godoc.org/gopkg.in/redis.v3 why so much methods ??

django-rq redux: advanced techniques and tools #Python #foss

This arsenal consists of everything you need to start working with #rq and #django comes fully stocked by Serafeim Pap @_serafeim_.

nswbmw / rtrie #Nodejs #foss

Like many others, I am attracted to magnets and intrigued by tries :) A trie is a one of the data structures I really like and this cute module uses them to do autocomplete.

Failover with Redis Sentinel (8 minutes to read)

Donatas Abraitis @abradona from Vinted Engineering @VintedEng kindly collected and put together the lessons he learned so we can benefit from his experience.

Spring Session Redis with Grails 3 #Java #howto

Redis-as-a-session-store is a common use case that has at least one howto in every language/framework that I can think of. For example, here is one for #Spring from Eric Helgeson @nulleric.

The SELECT problem in Redis (4 minutes to read)

If you are coming from a SQL background and are new to Redis, this short piece from Federico "Fede" Pereiro should really help you put things in order and find your way around (two index puns!). If you want more on the subject, here is a slidedeck I once prepared and have been meaning to turn into a series of posts since forever: http://www.slideshare.net/itamarhaber/20140922-redis-tlv-redis-indices

Pendecalogy Redis and Node.JS Slug out: In-process variables and remotely stored data (7 minutes to read)

The industrious Kyle @stockholmux is back with another observation about using Redis with #NodeJS – this time he's showing how you can actually decrease your RAM consumption just by using Redis.

Netflix / dynomite / wiki / Consistency #Redis #foss

@NetflixOSS's dynomite gets a new version with tunable consistency in the local region (intra-datacenter). Cool.

OH Mike Reinstein @dreamingbits > @antirez it seems every few years I re-discover how awesome redis is. Thank you so much for such an amazing, versatile tool!

How to monitor Redis performance metrics (11 minutes to read)

How to collect Redis metrics (9 minutes to read)

How to monitor Redis using Datadog (5 minutes to read)

Why write just one post if you can write three, right? The Datadog, Inc. @datadoghq seems to share this sentiment and spoils us silly.

Relocation Redis' community establishes home in the /r/redis subreddit

Much to the chagrin of email practitioners, Salvatore Sanfilippo @antirez had decided to move the community’s home from its long-time residence at the redis-db Google Groups mailing list to /r/redis. The rationale behind the decision boils down to evolving and revitalizing the community’s channels of communication. Presently, a few weeks into the journey, both redis-db and /r/redis seem to be thriving and while dubbed as an “experiment” that may fail or succeed, I find it fun (and a good excuse for surfing reddit on work time!) – how about voicing your own opinion in this discussion?

Extra bits

• The announcement in the redis-db mailing list
• Updates from /r/redis on Twitter via @RedditRedis

Minor release Redis 3.0.5 and 2.8.23 released (3 minutes to read)

ICYMI a minor Redis release with moderate severity issues resolved.

Migration Migrating Redis Data (6 minutes to read)

Parker Selbert @sorentwo reviews, compares and contrasts the ways you can take to migrating your Redis data. I would call this #RecommendedReading in heartbeat if it wasn’t for him quoting me – quoting me is the mark of a wise man or big fool (and you can quote me on that).

OH Marcus Smith @roomnoise > Redis is the duct tape of modern distributed engineering.

PSA Storing Data with Redis (5 minutes to read)

An educational piece from Mike Perham @mperham, creator of the OSS Sidekiq and Inspeqtor, on “the drawbacks of stuffing everything into one Redis database”. #RecommendedReading both because of the lessons (donts: namespacing & numbered databases, dos: dedicated instances) but also because of this gem of a sentence: “If you are using Redis for caching (and you should probably use memcached instead), …”

Clarifications about Redis and Memcached (6:37 minutes to read)

Salvatore Sanfilippo @antirez‘s retort to the above summarizes the real differences between the two technologies, namely Redis’ memory and allocator efficiencies, modifiable data, persistence, replication and Lua. I/O multi-threadedness is also mentioned and it is likely that Redis will get this capability the not-too-distant future given the work done on lazy delete (note: multithreaded I/O was also discussed during RDD15).

NEW! Indexing data for range queries in Redis

If there’s one key concept that really baffles many newcomers to the Redisverse it is most likely the fact that data is accessed by its primary (and only) key. Based on both personal experience as a long-time RDBMS person as well as upon my interactions with the Redis community, I believe that the crux of the matter lies in the pampering that we’ve grown so accustomed to when working with relational databases. In case you forgot, just like Redis, primary key lookup is also what RDBMSs excel at. However, a respectable RDBMS will let you get away with any syntactically-correct query and will return the data to you even if it’ll take it a lifetime to do so. To fetch any reply to a query that isn’t based on primary keys, an RDBMS will default to a full scan (it is, in fact, optimized for that) unless it is set up with relevant indices.

The robustness of modern relational query parsers and the ease with which one can CREATE INDEX on practically anything have made us expect the database to respond to all types of queries and at most “help” it by giving it a few friendly hints. And if you’re working in a relational model these expectations and modus operandi are perfectly acceptable. But Redis isn’t a relational database and won’t provide you with answers to arbitrary queries – you have to prepare the data according to the way you plan to retrieve it and that’s it. That basically means that you need to build your own 2ndary indices in Redis if you need an efficient non-primary-key-based way to access your data.

So how do you go about creating an index in Redis? That depends. Depending on your data and query, there are different ways to do that (see, for example, chapter 7 on searching in Redis in Action by Josiah Carlson @dr_josiah or my very own Redis Indices preso on the same). An advanced technique such as Composite Score Sorted Set Indexing (CSSSI) is very useful when you want to use two scores for your data, but even that is limited in precision to ~53bits and becomes practically unusable with higher dimensions.

For me the obsession with range queries in Redis had started when I was a young Redis advocate after stumbling upon this question from Stack Overflow: Search a key inside a block of keys with redis. I was haunted by a compelling need to answer but since then I was never too happy with my result (admittedly, it was written being tipsy at a wedding party of one of the Redis Labs team members). Since then, range queries kept popping in all kinds of places, and while a good solution was always possible on a per-case basis, a more generic approach seemed to be called for. The final straw (in the haystack?) of the first act was yet another Stack Overflow question: Intersection of two or more sorted sets

Second act: as RDD15 was getting nearer, I advocated the need for range queries to Redis’ developers and provided the numbers from the Quadtree PoC to jumpstart the discussion. First, I pitched it internally to the lead and the team of open source Redis developers and afterwards at RDD itself. A detailed accounting of the ensuing discussions is outside the scope of a newsletter item that’s already getting far too long as it is, so I’ll stop blogging and get to the immediate outcomes.

Documentation: A new Secondary indexing with Redis page has been added to the corpus by Salvatore Sanfilippo @antirez per the “good software means good documentation” principle that he practices (reminder: if you want to contribute to the documentation that’s simple – it’s all open source).

Redimension: Also from Salvatore Sanfilippo @antirez is the Redimension #Ruby library that has two purposes. Primarily, it takes away the pain from using lexicographical ranges to perform range queries on multi-dimensional elements. On top of that, it is an experiment for exploring an indexing (indicing?) API that could be added to Redis regardless of the underlying data structures (i.e.g. btree, Quadtree, kd-tree, R-tree or others). My contribution was to port and implement Redimension in Redis-compliant #Lua that can be used from anywhere.

I’m pretty confident that this isn’t the last time you’ll be hearing about indexing, ranges, trees and the rest of that good stuff in Redis.

Power to the People Recent improvements to Redis #Lua scripting (timeless)

TL;DR also post-RDD, a debugger for Redis Lua scripts that is contained in Redis and effects replication for Lua scripts from the purist, fixed-width article writer, somewhat-groggy-in-the-morning-until-the-coffee-kicks-in video overview-and-demo (33:40 minutes to watch) recorder and a big time cheater who develops Redis :) Also, mark your calendars and get ready for a v3.2 RC scheduled for this December.

Honorable Mention: Marijan from Tikoder @trikoder had recently considerably ramped up his workflow for debugging Redis Lua scripts to near perfection – http://www.trikoder.net/blog/redis-and-lua-scripts-new-workflow-89

OH Sergei Egorov @bsideup > Damn it! Redis is so fast so I spent 30 minutes to figure out that "0ms" length of the trace is not a bug >_< /cc @antirez @RedisLabs

OH Ossie Okeke @ossieokeke > @antirez ….does Redis have a psychic feature? I think my request just came back a few milliseconds before i made it!

Security A few things about Redis security (1337)

You should know better than leaving your servers wide open to the internets, but if you need a reminder of just how dangerous it is to let people access an uprotected server here you go. Now go and make sure that the requirepass configuration directive is enabled on your server and then read the Redis Security documentation page.

Secure Redis #Security #howto

While on the topic of security, José Coelho @ZeCoffee had put together a detailed guide on setting up highly available Redis for those who are bothered with compliance issues.

NEW RELEASE Redis 3.0.3 is out! (<1 minute to read)

An existential release from Salvatore Sanfilippo @antirez that is mostly about fixes and variadic arity.

OFFICALLY PROVISIONAL redis:// URI Scheme (<1 minute to read)

Thanks to Chris Rebert @cvrebert's initiative and efforts, IANA @theiana has granted provisional status to the proposal #MERZFTW – and the first Redis client that will officially support the provisional URI scheme is…

OH Daniele Alessandri @JoL1hAHN > Starting w/ Predis v1.0.2 it’ll also be possible to provide an URI using the redis:// scheme as defined by redis:// http://www.iana.org/assignments/uri-schemes/prov/redis #redis

Minor release nrk / predis v1.0.2 #PHP #foss

True to his word above – kudos Daniele Alessandri @JoL1hAHN

alpha MSOpenTech Redis on Windows 3.0 Release Notes (<1 minute to read)

Redis on Windows 3.0.100-alpha1 is out from Open at Microsoft @openatmicrosoft – encouraging.

Automagically storing Python objects in Redis #Python #howto

It appears that while Magicians work with rabbits and doves, Automagician JP Verkamp @jpverkamp prefers snakes. Cool.

Miss Manners and Waltzdb (~15 minutes to ponder)

"While durable_rules is a framework for complex event coordination, its linguistic abstraction is also suitable for solving business rules problems such as constraint propagation" – and this is just the first sentence! Jesus Ruiz @jruiztwi provides many more like these and fascinating research material.

UV Logic Using Redis Bitmap #Pattern #slides

Once you've realized that UV means Unique Visitors, everything makes perfect sense – from Jooyong Oh

Video Why the Redis community is awesome! (3:10 minutes to watch)

@ObjectRocket had recently released several polished video productions that were shot during RedisConf 2015. My 1st pick is, naturally, this one in which the first 90 seconds open with Chris Lalonde @lalonde_cal who thinks long and hard before answering, Matt Stancliff @mattsta emphasizing the importance of openness and Matt Barker @mbarker sharing his impressions of the community. The remainder is by Salvatore Sanfilippo @antirez.

Other videos in the series feature other celeb-redis, including: Yiftach Shoolman @Yiftachsh, Bill Anderson @ucntcme, Conrad Weidenkeller @Conrad_W (p.s. ty!), Joe Engel @Joe_Racker, Matt Cowger @mcowger and Jon Hyman @jon_hyman.

pmwkaa / serenity #C #foss

By Dmitry Simonenko @pmwkaa is project whose home page, http://serenitydb.org/, describes it as "disk storage and real transactions under Redis compatible protocol", boasts "support of Consistent Cursors, ACID transactions, Stored procedures, etc" and uses sophia (by the same author) as the underlying database. Phew.

Getting started with Celery and Redis #Python #howto

I believe there's no such thing as too much details and it appears that Akshar Raaj @_akshar shares this belief and his article – a well organized structure that lays out everything you need to know about starting to use Celery.

Rapid Server Development With Koa.js, Redis, PM2 and ES6 Generators #NodeJS #howto

Oleksii/Alex Rudenko @orKoN spills the beans (is this still considered a passable pun in Node.js? I guess not) and provides a breakdown of how his tips server is built. Thoughtfully included is the starter app as well: https://github.com/60devs/koajs-starter-project.

pote / disc #Ruby #foss

Simple (self admitted) Ruby jobs powered by Disque brought to you by pote @poteland #AlternativeToSidekiqAndResque

Save Node.js headaches with Lua and Redis #NodeJS #howto

In the 11th chapter of what is officially the longest series about Node.js and Redis, Kyle @stockholmux finally joins the rest of us who are howling at the moon and unleashes the raw power of #Lua scripting.

ton31337 / redistop #Ruby #foss

A tiny script to run from the command line that prints a summary of your what operations your Redis is doing. Does not have the performance impact of MONITORing – by Donatas Abraitis @abradona.

Scripting and Profiling Improvements in StackExchange.Redis (3 minutes to read providing you know your #DotNET)

An overview by Kevin Montrose @kevinmontrose of the latest in supporting #Lua scripts and providing a profiling interface in the StackExchange.Redis client.

Optimizing Redis Usage For Caching (2 minutes to read)

A quick reminder for some, a possible eye-opener for others: dedicated instances, tune persistence, remember the memory and practice intelligent caching. Word. Via Soren @sorentwo.

Speeding up Existing Apps with a Redis Cache #PHP #howto

…or you could just stick a Redis in front of your database and use it a as an unintelligent cache. Bruno Skvorc @bitfalls, the author, promises more features down line #CliffHanger

silvpol / redis_runner.lua #Lua #foss

Neat-O!!! Another way to debug Lua in Redis, or rather Redis in Lua, or maybe Lua in Redis in Lua. Whatever the case may be, Swav Swiac's works definitely strikes a chord with me.

Writing a Redis client in pure bash, part 1 #Bash #foss

Perhaps the best way to pick up a skill is to start practicing it and with Bash you can’t be bashful – Raymond Ranelli @RRanelli is bashing together a REPL for Redis.

Deleting Large Objects in Redis #Pseudocode #Ruby #patterns

Delay the inevitable with this handy collection of patterns for lazy deletion of BIG Redis objects – Hashes, Lists, Sets and Sorted Sets – from Tyson Tate @tyson via RedisGreen @redisgreen. And just in time because…

OH Salvatore Sanfilippo @antirez > Finally working to lazy free for Redis…

CLIQZ's first major open source contribution: Keyvi, the key value index (10 minutes to read)

Some companies use open source databases and some build their own – CLIQZ @cliqz started as the first type and now belongs to the second with its #foss Keyvi project. Intended for high-read workloads, Keyvi offers fast access to highly compressed data, and uses “finite state transducer” technology (this FST, it is I suppose some kind of audio-vibratory-physio-molecular transport device?) to deliver the magic.

Free Promotion Hack The Block – An ObjectRocket Hackathon ($25K in prizes)

Got a killer idea for the good of all and a thirst for cash? Think you have what it takes to take away the grand prize? Registration is open for everyone who wants wring the best out of #MongoDB and #Redis (I only politely ask for the usual 10% finder's fee out of all future winnings).

Thanks Pivotal, Hello Redis Labs (timeless)

Salvatore Sanfilippo @antirez thanks @Pivotal and @VMWare for sponsoring the Redis project over the last years, joins the @RedisLabs‘ team.

Salvatore Sanfilippo – Welcome to Redis Labs (3 minutes to read)

The creator and spirit of the Redis community had just joined Redis Labs – for me, this move is the professional equivalent of religious ecstasy but I think I had managed to keep my emotions completely out of the post :)

Get A Redis #Go #foss #free

A dead-simple open source hosted Redis service running in containers on DigitalOcean by Mohamed Bassem @MohamedBassem. What should RaaS providers such as Redis Cloud, @openredis, @RedisGreen, @RedisToGo & @ObjectRocket do in response to this type of competition?

OH Matt Ranney @mranney > node_redis could use help. @brycebaril and I have moved on, so we made https://github.com/NodeRedis . LMK if you want to contribute.

integrii / go-redis-migrator #Go #foss

This utility will let you migrate keys from one database to another by Eric Greer @integrii.

Optimizing Caching: Twemproxy and Memcached at Flickr (8 minutes to read)

A time lapse-like deep dive into the caching layer used at @flickr by our guides Tague Griffith @tague and John Troxel @neurotroxel.

gossiperl / erl_embedded_redis #Erlang #foss

Rad G @rad_g made an embedded Redis server for Erlang over the weekend – should be useful for integration testing.

Don't get burned by Redis ConnectionMultiplexer; A sample wrapper #DotNET #howto

Gavin Barron @gavinbarron learned the hard way to share his ConnectionMultiplexer across class instance – here he shares the lesson and a sample wrapper that implements it.

Setting up a Connection with StackExchange.Redis #DotNET #howto

By coincidence (I verified that) two days later comes in this howto from Daniel D'Agostino @dandago2 – a deeper dive into the perplexing world of the multiplexer.

OH Mike Perham @mperham > Warning: if you have thousands of Redis connections, you need to tune the "hz" variable: https://github.com/mperham/sidekiq/wiki/Using-Redis#tuning #RedisProTip

Speed Up Your Rails App by 66% – The Complete Guide to Rails Caching (14 minutes to read)

Benchmarks – can't do with them, can't do without them. In this delightfully detailed and methodical post, Nate Berkopec @nateberkopec pits no less than five cache backends for #Rails applications one against the other: ActiveSupport::FileStore, ActiveSupport::MemoryStore, Memcached, Redis & LRURedux.

msmichellegar / best-todo-ever #NodeJS #foss

I'm a sucker for anything that has a name that consists of strong positive superlative – I mean, if it ain't the best the author wouldn't have called it that, right? You be the judge in the case of Michelle Garrett @msmichellegar who used @hapijs and Socket IO @SocketIO for building the best todo app on Redis.

Caching in Java with JOOQ and Redis #Java #howto

Need to cache your DB calls? No problem, just read this guide from Aakash Japi @logicx24 that shows everything on how to intercept the queries, get the data and invalidate it.

OH @yburyug > BR "If I could only take one database with me to a desert island, it would be #Redis" <- what does BR mean?

Comparing an elephant to a washing machine: Redis and SimpleDB (9 minutes to read)

Despite an hiatus to his ever-growing Node.js/Redis series, Kyle @stockholmux compares and contrasts these two vastly different solutions and ends with some useful rules of thumb (@stockholmux – also, thanks for jumping in to save the day the other day).

Redis + Node.js + Socket.IO — Event-driven, subscription-based broadcasting #NodeJS #howto

A KISS-oriented walk-through from the un-Twitterable Sachin Joglekar.

Efficient computation and storage of basic data statistics using Redis #Python #howto

On average I find such nuggets absolutely priceless because someone else, in this case the same Sachim Joglekar from the item above, did all the heavy thinking for me #YourMilageMayVarianceThough

Redis at eHarmony as a Store and Cache (5 minutes to read)

@eHarmony‘s Platform Team Principal Software Engineer Vijay Vangapandu found his match with Redis (pun expected but unavoidable, sorry) when he set out to build a low latency authentication (micro) service. The post succeeds in keeping a relatively light technical tone and still capture the use cases's essence. The author, on the other hand, fails at keeping his subjective fondness for Redis private to himself… I and I like that :) Another nice find is how to get over the pesky Jedis connection pool size limit, but that’s a different story.

Transparent Huge Pages and Alternative Memory Allocators: A Cautionary Tale (7 minutes to read)

Running out of memory and having your Redis server killed is an unpleasant ordeal, as experienced by an anonymous member of the @digitalOcean team. THP are hardly news any more and Redis even warns against it if it is enabled, but some lessons are learned the hard way – read this to avoid the same happening to you.

sandfox / node-basic-redis-factory #NodeJS #foss

Is a "module that should make creating redis client instances from connection strings much easier", as described by the module's author – Mad Minimum @sandfoxthat who's also open for suggestions on his WIP.

OH Jan-Erik @badboy_ > "Use Redis-red: #D42E15" — "Please, tell me you looked it up" — "I got it tattooed to my forearm" — I may have shocked @seppo0010 right now

Evolving NoSQL Databases Without Downtime (looks like a 40 minutes to read at the very least, but maybe only because of the academia layout)

A team from the University of Maryland Computer Science Department @UMDCS had come up with a neat way of rolling out schema changes in a schemaless database with little impact on availability. In a nut shell, a process remaps the requested key names (old<->new) in flight while the database is in an Schrödinger-cat-like state.

Tynd Beta – Disque hosting for Heroku (1 minute to read)

Congratulations and bon chance are in order for one of the community's most respected pillars, Michel Martens @soveran, on launching the first Disque-as-a-Service offering! If you're looking for the latest in distributed queues, look no further and take this new offer for a spin – your feedback will be appreciated by the developer and the provider, I&39;m quite certain.

OH Salvatore Sanfilippo @antirez > And… after 40 commits the GEO API is part of Redis, just merged into "unstable".

Introducing the Geo API in Redis #Redis #howto

The early bird edition, courtesy of Cristian Greco @cristiangreco.

OH Salvatore Sanfilippo @antirez > Ok now all the Geo commands are documented \o/: http://redis.io/commands/georadius Usually happy to write doc, but this was too much in a few days ;-)

Why my next CMS system will have an in-memory database as primary data store? (9 minutes to read)

I like this one – sensible arguments based on experience and domain knowledge in the context of a well-defined use case. Bonus points go to S Ramdas, author and CEO of Netzary InfoDynamics @netzary, for taking the next step and actually practicing what he preaches on that same blog.

saltmine / redis-gadgets #Python #foss

What is supposedly a collection of helpers is ATM just a single one that does tracking of unique things. It looks promising though, so lets hope that Keep.com @keep's team will keep adding goodies to it.

Introducing Disque (21:20 minutes to watch)

One way you can jump into action with Disque is by watching Salvatore Sanfilippo @antirez's session at the @dotScale European conference from exactly 1m+1d ago. The slides can be found at http://antirez.com/misc/DotScale2015.pdf.

stephenmcd / curiodb #Scala #Akka #foss

After a gestation period of 6 months, the brainchild of Stephen McDonald @stephen_mcd's curios mind comes into the light of day. It is a distributed and persistent Redis clone that does not claim to be a drop-in replacement – how curiously refreshing :)

Build a Real-Time Markdown Editor with Node.js #NodeJS #howto

Asif Ahmed @sifxtreme provides a solid tutorial that's so aptly named that it makes this paragraph almost redundant had it not been for the attribution that it provides.

reborndb / qdb #Go #foss

However, this one does: "a fast, high availability, fully Redis compatible store". QDB supports multiple types of backend storages (RockDB, LevelDB and GoLevelDB) and can sync with Redis. A project from @ngaut1 who appears to have the right experience based on his involvement with Codis and RebornDB…

RebornDB: The Next Generation Distributed Key-Value Store (~10 minutes to read)

If imitation is the sincerest form of flattery, then Redis should be feeling pretty smug. If someone (me?) was to do a headcount of all its clones/reimplements/embetterments/forks and other utensils, then I'm positive the result would require at least 11 bits to store. Perhaps even 12 bits now that @siddontang (reminder: LedisDB, xcodis) and @ngaut1 (reminder: item above) have joined forces (or perhaps they are the same person? seriously guys, what are your names?). Be the case as it may, RebornDB is made up of a proxy that clusterifies backend stores (i.e. QDB or reborn-server [yet another modified version of Redis]), uses a coordinator (zookeeper or etcd) and and provides management capabilities. Via the always-awesome High Scalability @highscal blog.

gosuri / go-store #Go #foss

Personally I find Redis dead simple and consider most abstractions distracting, but I guess some may find Redis too much for their simple KV business hence this project from Greg Osuri @kn0tch.

OH Nick Craver @Nick_Craver > #redis operations on the mobile instance before restart: 511,251,825,000 Note: reboot was for firmware patching and MTU changes only.

Moving Millions of User Sessions from MySQL to Redis (12 minutes to read)

Hootsuite Engineering @HootsuiteEng team members Anubhav Mishra @anubhavm and Luke Kysow @lkysow share their battle stories with the public. Twemproxy is used to eliminate timeouts from the PHP application to AWS' ElastiCache that can do a failover in 60 seconds (ahm ahm, why not try Redis Cloud? :)).

Redis SPOP Culture: Censored Lua vs Atomic Transactions with Node.js and Redis #NodeJS #howto

Kyle @stockholmux had opened this block and is also closing it. In this piece, he is shocked to find that non-determinism is a Lua no no so no SPOP for you. He then goes about devising a clever, although inefficient-by-own-admission, way of doing it using MULTI/EXEC, a bunch of Set operations and temporary keys.

OH Mike Perham @mperham > TIL you can WATCH a non-existent key so Redis will abort the transaction if someone else creates it. @redisfeed #RedisProTip

Geo is coming to Redis – computational neuroscientists happily excited around the world

A new branch, 10s of commits, a test script and numerous tweets from Salvatore Sanfilippo @antirez tell us that Redis is shortly gonna get much awesomer, per 3.2 plans. Once that's done, it has been OHed that Disque will get the attention it deserves and then it' to be the Bloom season. Oh yeah.

Redis is easy. Redis is trivial. Redis is HARD! #Redis #howto

Good catchy title and solid details from Command.io @commando_io on how to install, replicate and make your Redis discoverable and available – you definitely want to follow these instructions if you plan using Redis for production purposes. Or, you can simply use Redis Labs' products. Our products are desig… (Editor: please keep all sponsored content confined to the newsletter's bottom section).

The Current State of Container Usage (7:06 minutes to read)

Surveys are fun, and with containers taking the world by a storm this one from DevOps.com @devopsdotcom and ClusterHQ @clusterhq is a pretty sweet treat. I swear I would've liked even if it hadn't found (in question 17) that #MySQL, #Redis and #PostgreSQL are the top 3 stateful services in use :)

BIG RED BUTTON exploits Redis flaw to fix Redis flaw (2 minutes to read)

While not strictly news for this newsletter's readers (new subscribers: see issues #46, #47 and #48), the The Register @TheRegister's characteristic reporting style is amusing as usual and is therefore included for merit rather than completeness.

OH Salvatore Sanfilippo @antirez > @JeremiadLee You can list keys by pattern without blocking the server on the CLI as well: redis-cli --scan --pattern '*:12345*' #RedisProTip

Redis Configuration – Redis Series Episode 9 #Redis #video

In a series mostly about #PHP's #Laravel, this bold step taken by Christophe Limpalair @christophelimp/@ScaleYourCode focuses exclusively on the bear necessities of life.

adriano-di-giovanni / node-redis-keychain #NodeJS #foss

Control your keyspace with dignity and abstract aloofness with this lovely helper from Adriano Di Giovanni @codecreativity. Personally, I prefer looking at my keys straight at their eye, but I know that to each his own.

Get more than a cache back! #NotOnlyAzure #NotOnlyDotNET #slides #video

Time to indulge the old intro-to-Redis fetish with 42-slides (yes!) deck from Maarten Balliauw @maartenballiauw. I must admit that given the strong whiff of #Azure/#DotNET that the preso gives, I was more than pleasantly surprised by the fact that it is all but non-existent in the content that turns out to be a concise, clear and well-organized Redis 101. The video from the talk is also online at https://vimeo.com/131641614 – definitely a keeper for future use!

emehrkay / rgp #Python #foss

Is a graph database implementation from Shaniqua's PhoneMark Henderson @Emehrkay. Since the author had demonstrated desire for learning, a chief avocadocommunity member had tipped him about the The Command That Must Not Be Used – KEYS #RedisProTip

The Evolution of Fault Tolerant Redis Cluster (18 minutes to read)

It is quite possible to pulling together your very very own apocalypse-proof setup using only Redis, DNS routing, the Redis Admin page, Sentinel, HA Proxy, Multi-AZ and twemproxy as reported by the Personalization team at BloomReach @bloomreachinc (where they use it for storing 16 billion URLs and controlling Cassandra clients, but that's another [highly-expected!] post). Or, you could use Redis Labs to build a production-grade cluster that scales as your dat… (Editor: last warning)

OH Matt Joiner @anacrolix > That moment when you realise you weren't reusing #Redis connections and shit is about to get even faster. <- oh yeah #RedisProTip

#askingforafriend

OH Salvatore Sanfilippo @antirez > Dear Italian friends, I may receive a grant about OSS, I want to give it to people helping Redis/Disque. Any legal hint? Need to pay taxes?

OH Josiah Carlson @dr_josiah > Hey #Python and #Redis folks, I want to write something, but I don't know what to write about. What do you want to know?

Community Redis Aggregator #Redis #aggregator

The only thing better than knowledge is meta knowledge, which is exactly what planetredis.org is all about – the best of Redis content under the same roof. And the only thing better than meta knowledge is OS meta knowledge, which is exactly how the team at @VividCortex and "The Red(is) Baron" Baron Schwartz @xaprb had built this one – both source code and source feeds are open at GH and awaiting your PRs.

seppo0010 / rsedis #Rust #foss

It takes all kinds to make a world and in our world one of the things that make "Third Time's a Charm" Sebastian Waisbrot @seppo0010 unique is his hobby of implementing Redis. After first doing it with rlite, the embeddable Redis-like engine, we are presented with the Rust implementation. Do feel free to encourage Sebastian with implementing Redis in more exotic ways as practice makes perfect and I, for one, can't get enough of Redis :)

moonglum / storage-pod #NodeJS #foss

From what I've seen so far, Node.js modules fall into one of two major categories: the how-come-no-one-thought-of-that-before and the who-in-his-right-mind-would-do-this. This one lets you do just two things – store a value and get back a key, give a key and get back the value. Sounds simple? It is :) Yet this is very effective for most purposes so definitely first category material – by "He Who Thunk It" Lucas Dohmen @moonbeamlabs.

Plans for Redis 3.2 (6:37.9 minutes to read)

Redis' creator "The Benevolent Dictator" Salvatore Sanfilippo @antirez outlines his plans for the next feature-focused version. Goodness begins with Matt Stancliff @mattsta's geo hashing API and Bloom filters that are a-coming (an unexpected synergy from the Disque project). If that&39;s not enough for you, there are new List operations, AOF improvements, more clustering power and, last but not least, several memory optimizations that will lower Redis' RAM overheads dramatically in some cases (shameless plug: by the extremely talented team here at Redis Labs).

Using Redis as Your Main Superfast Persistent Database in Node & Express #NodeJS #howto

"Title Author Extraordinaire" Stefan Fidanov @fidanov is also very good at writing the actual article – a recommended 3-in-1 introduction.

Redis, set, node. #NodeJS #howto

"One More Time" Kyle @stockholmux continues to set an example.

!(Ivory Tower)

OH Jan Erik @badboy_ > @antirez https://github.com/antirez/redis/blob/unstable/src/sentinel.c#L1786-L1787 – clang rightfully complains that `slave_addr` is never read after assignment.

OH Salvatore Sanfilippo @antirez > Using the clang static analyzer @badboy_ found an hard to trigger Sentinel bug: https://github.com/antirez/redis/commit/821a986643717018cad8af9f35cba49818e60294

OH Jan Erik @badboy_ > Good thing I'm studying the basics of static analysis, model checking and program verification. It has a real-world value. :)

Can someone ELI5 what Redis is and in what circumstances it should be used? (self.rails, 12 comments)

Considering some of the discussions on Reddit, this one turned out pretty well (I was expecting a full-out flame war, but that's probably just me being a pessimist). For the less initiated, ELI5 stands for Explain Like I'm 5yo. Participation is encouraged.

Redis Hot Patch (3:18.45 minutes to read)

Security researcher "Just Because I Can" Ben Murphy @benmmurphy latest escapade uses the same Lua vulnerability that he had unveiled a week earlier to hot patch Redis to block any sandbox escapes.

Prototyping fun with Flask and Redis. #Python #howto

A fun intro to prototyping with Flask and Redis from "I Haz Photoshop" Roberto Calderon @calderonroberto that I had actually helped with (to an extent ;)).

OH Daniel Schep @schep_ > switch to redis. holy shit that was easy

Beyond Request-Response #Django #Python #howto

Instead of sticking with the traditional request-response model, "I love Django dearly" Andrew Godwin @andrewgodwin shows how to use Redis to decouple the request from the worker serving it.

OH Bryan Downing @quantlabs > @akmalchaudhri awesome awesome awesome news on redis, screw the rest go with the best

Redis 101 #Redis #slides

On average, I get to review 3 intro-to-Redis slidedecks every week (even wrote a couple of my own :)), but this one is perhaps the most elegant of all that I've seen to date – by Peter Cooper @peterc ht Tim Spann @PaaSDev #VintageClassic

Conflict and Irrelevance in NoSQL Land (13:14 minutes to read)

Virginia Backaitis @actbrilliant from @CMSWire reviews the recent tsunami of comperative benchmarks from NoSQL vendors — the one from @MongoDB, from @Couchbase, @DataStax's and even Redis Labs' — and doesn't hold anything back. Favorite quote: "there are three classes of untruths in the world: lies, damn lies and benchmarks." from Peter Coppola @pbcoppola of Basho Technologies @Basho (and BTW, all benchmarks are is a bunch of averages slapped on a graph ;))

Simple Social Network in Go with Redis Pt.1 #Go #howto

Steven Myers @slmyers11 took upon himself to explain how one would go about using Redis and Go for building a social network. I've been waiting patiently for him to complete the 3rd and final part before presenting the series to you: Pt.2 & Pt.3 (BTW, on average, it took Steven 2.5 days to write each part).

Parsing the Redis TCP Protocol (8 minutes to read)

Pipelining makes sniffing Redis' chitchat harder, but that didn't stop Baron Schwartz @xaprb and the team at @VividCortex from doing it. The result: Network Analyzer for Redis.

OH Matthew Taylor @rhyolight > Just had my first experience with #redis and it was great. Yeah, I'm pretty late to the NoSQL party but whatever. &lt- better late than never, better today than tomorrow, better now than later and I'd better shut up this instant

tiredpixel / pikka-bird-collector-py #Python #foss

Poor @tiredpixel is loosing sleep because he/she is building something cool – Pikka Bird is an ops monitoring tool and this is the collector script for all kinds of database stuff: #MongoDB, #MySQL, #PostgreSQL, #RabbitMQ, #Redis and some system metrics as well. As a co-sufferer from sleep deprivation, I can think of worst reasons for insomnia and we both share an interest in "big, small, and napkin-sized" data.

Comic relief (3 puns in rapid succession)

OH Tom White @polytomous > @amygdalama I once saw a Redis Tribute band, but they were just a little bit off key. :(

OH Tom White @polytomous > @itamarhaber I've been laying low lately. There's people on the streets busting CAPs and I don't want to talk distrusted systems right now.

OH Tom White @polytomous > @itamarhaber If you're looking for more redis puns, I heard a Wu-tang song full of them. "Cache rules everything around me" or something.

CVE-2015-4335/DSA-3279 – Redis Lua Sandbox Escape (4 minutes to read)

In light of last week's security exploit, here' what you need to know to protect your Redis database from attacks. Key takeaway: use password authentication. Bonus takeaway: create your own DSA ID.

Data Types in Redis – Redis Series Episode 8 (20:48 minutes) #PHP #Laravel #video

Christophe Limpalair @christophelimp a.k.a. @ScaleYourCode dedicates the 8th chapter of his series to Pratik Shah @pratik07shah and 4 of Redis' data types – Hashes, Lists, Sets and Sorted Sets.

High-performance messaging with Go and Redis (22:11 minutes) #Go #video

Chris Goddard @goddardcm, Co-Founder & CTO of Charge @ChargeComm (a.k.a. "the posh WhatsApp") explains everything you need to know about building a messaging application with Redis in this excellent talk from the recent @Twilio SIGNAL event.

fastest963 / node-redis-rolling-limit #NodeJS #Lua #foss

Neat idea – a rolling rate limiter that's partly implemented with server-side Lua – from James Hartig @jameshartig.

It's The Future (4:20 minutes to read)

Everybody's a comedian in this issue and Paul Biggar @paulbiggar from @CircleCI is no different. In this webscale piece he presents a contemporary-yet-apocalyptic dialogue between a dinosaur and a hipster in which everyone gets mentioned (/cc Kyle Kingsburry @aphyr) – a few FQs: "Heroku is dead", "Ew", "Composability is the future", "no-one understands Paxos", "It's San Francisco. Everyone's into distributed systems and BDSM", "No, nothing like Redis. etcd is distributed. Redis loses half its writes if the network partitions", "Isn't it glorious?". I've seen the future baby: it is #gifee

Azure / aspnet-redis-providers #DotNET #foss

Speaking of the future, I've been waiting for this day to arrive for some time now – with the ASP.NET providers now open sourced, anything is possible (well, almost anything anyway). For example, now there's little need for side-loading an SSL certificate to the StackExchange.Redis client – thanks again Marc Gravell @marcgravell for that brilliant assist!

brainix / pottery #Python #foss

"Redis is awesome, but Redis clients are not awesome." <- am I detecting resentment against Andy McCurdy @andymccurdy here? "Pottery is a Pythonic way to access Redis. If you know how to use Python dicts and sets, then you already know how to use Pottery." <- Ah, that actually makes perfect sense :) thanks to Raj Shah @brainix.

OH All about the Zen @monkchips > "look at salvatore over in italy" – and we ALL know what he's talking about. #librato #solarwinds #redis

 

 

Untangling Redis sort results with Node.js and lodash #Nodejs #howto

Lucky numbah 7 from Kyle @stockholmux teaches what you need to know about client-side sorting – yummy as usual (and I may add Node.JS to my CV at the pace that Kyle's bringing it on :)).

Getting started with Spring Security, Spring Session and Redis #SpringBoot #howto

Learn how to bootstrap Spring Boot with this simple-to-follow howto from Driss Amri @drams88.

OH Ho-Ling Poon @holingpoon >Redis watch is the coolest newsletter ever. https://redislabs.com/redis-watch-archive/45 &lt- some people have a knack at nailing profound truths succinctly :)

Remote Software Coding and Tutoring From Paradise with Rick Hurst (44:01 minutes to watch)

An interview with Rick Hurst @HTML5Rick that touches practically everything. My take: "Redis – ar-ey-dee-ie-ess – it's very very good".

Redis Sentinel & Redis Cluster – what? (<3 minutes to read – seriously)

Speaking of very very good, here' a sweet and short piece from Jan-Erik Rediger @badboy_ that explains in the simplest terms what Sentinel and Redis cluster are #InstantlyGolden

Redis Cluster or: distributed systems are hard (58 slides)

If you were left wanting more, here're the slides from a talk that Jan-Erik Rediger @badboy_ gave last month at PHP-UG Düsseldorf @PHPUGDus.

Nifty redis tricks #Ruby #howto

Even old dogs can learn 3 new tricks – throttling email alerts, aggregating metrics and lock operations – brought to you by Jordan Bach @jbgo.

sent-hil / bitesized #Go #foss

Senthil Arivudainambi from @Koding made a bitmaps-powered analytics solution.

6 Free Technical Classes From Pivotal Education (6 minutes to read)

Grab some free #BigData chow for the brainz from @Pivotal's buffet – now serving #Greenplum, #GemFire, #PivotalHD, #HAWQ, #CloudFoundry and #Redis.

gutefrage / aurora-redis #Aurora #foss

I admit that this can't quite replace our Redis Labs Enterprise Cluster, but this repo is certainly a nice find for the DIY kind of girl/boy who likes playing with Apache Aurora @ApacheAurora – from Gute Frage @gutefrage_net.

The future of lettuce (8 minutes to read)

The future, as told by Mark Paluch @mp911de, author of the Java lettuce Redis client. I'm not using lettuce (I don't Java) but Mark's efforts at maintaining his project are commendable – he updates it all the time with major capabilities and in my book passion means quality.

OH Andy Diep @andydiep >6k recs per day. Hitting 1 M recs. reading access is constant 1. It's magical!!! Go Redis.

Redis & MongoDB: Stop Big Data Indigestion Before It Starts #MongoDB #slides

These are the slides from the talk I gave two days ago at #MongoDBWorld 2015 about an amazing use pattern for the two best-complementing databases there are – Redis and @MongoDB. The session wasn't recorded regrettably (any chance of fixing that next year? Meagen Eisenberg @meisenberg) and slides are worthless by themselves (or so I'd like to hope), so feel free to hit me with any questions! BTW, although I had a nasty cold it was a great event to be at with buzz a-plenty, excellent sessions and amazing people. I also finally hooked up in the flesh with Tim Spann @PaaSDev who is, although usually uncredited, one of my dependable sources for content :) OTOH, despite having womanning/manning booths right across from each other, I did not get to meet Nikki Tirado @NikkiTirado and I fear an anti-climax once we do in all eventuality and fullness of time. Last tidbit, regardless my cold, the night before the session I had a mild case of indigestion that had kept me up… I'm such a cliche :)

Redis 3.0.2 and Redis 2.8.21 are out (3 minutes to read)

An immediate response from Salvatore Sanfilippo @antirez to a serious exploit in the Lua sandbox as reported by security researcher Ben Murphy @benmmurphy in his excellent post from earlier today – Redis EVAL Lua Sandbox Escape. Besides that, there is also a slew of new Sentinal stuff and a tweaked ZADD.

OH Stefan Prodan @stefanprodan >Finally! The port of #redis cluster v3 for windows has started https://github.com/MSOpenTech/redis/issues/231

mdahiemstra / nagios-check-redis  #nagios  #foss

Is a simple plugin for nagios to check status of a Redis server from Michel Hiemstra @mdahiemstra.

OH Kyle Drake @kyledrake > Redis Cluster is great. They're honest about what it can and can't do. I really miss that honesty with most DBs. http://redis.io/topics/cluster-tutorial

Redis Architecture Diagram (1 minute to watch, understanding it is a different matter)

Matt Stancliff @mattsta's epic diagram was recently updated ICYMI.

Managing modularity and Redis connections in Node.js #Nodejs #howto

Kyle @stockholmux is spoiling me silly with a new installation about Redis and Node.js on an almost weekly basis. This time, I learned how to save on setting up and tearing down a connection for each module.

Recovering A Sentinel Configuration #Sentinel #howto

All you ever wanted to know about (loosing your) Sentinel (configuration and recovering it) but were too afraid to ask by The Real Bill Anderson @ucntcme.

OH Dan Connor @thestereobus >Redis' feature set is just endlessly helpful.

Redis, Express and Streaming with Node.js and Classic Literature(?)  #Nodejs  #howto

Have I mentioned that Kyle @stockholmux is spoiling me silly? This time I learned how to almost stream data from Redis via the use of GETRANGE and the redis-rstream library from Jeff Barczewski @jeffbski.

Redis and Connected Clients #Bash  #foss

Luca Francesca @The_Lukas_1988 is cooking up a smart script that reports on clients connected to your Redis after filtering non-existant domains and IP-only connections.

OH Salvatore Sanfilippo @antirez > What about Redis 3.2 focusing on client-side caching? With Redis helping to keep a client side in-memory cache consistent?

Integrating Redis, PostgreSQL and Neo4j in CentOS 7 #Redis  #PostgreSQL  #Neo4j  #CentOS7  #howto

A wonderful recipe for a polyglot setup from Marcos Ortiz @marcosluis2186.

hashslot_keys.txt #cluster #txt

Salvatore Sanfilippo @antirez > "A table with a key name hashing to each of the 16384 hash slots of Redis Cluster, for testing"

Redis and Laravel Series #PHP #Laravel #video

I'm a sucker for series and here's one that completely escaped my radar until its 6th episode – I still need to catch up with all this goodness from Christophe Limpalair @christophelimp via @ScaleYourCode:

1. Predis (10:36)
2. PhpRedis (10:04)
3. Top Viewed Pages (21:29)
4. Cache Database Queries (9:21)
5. Deleted :)
6. Tagging Articles, Products (18:59)
7. Twitter newsfeed with Redis (25:48)

OH Guney Can Gokoglu @gcg > Note to self: DONT f*cking REMOVE LIVE REDIS CLUSTER! <- word.

Alternative Redis-Like Databases with Python #Python #howto #foss

Charles Leifer @coleifer, author of Warlus, begins with a review of 3 Redis-like projects – Sebastian Waisbrot @seppo0010's Rlite, siddontang @siddontang's LedisDB and Symisc @unqlite_db's Vedis (unmaintained ATM) – and ends with the aptly-named Tusks that provide support for these in Warlus.

takenet / elephant #DotNET #foss

Is a persistence library that provides common data structures as composable elements to abstract any storage engine, including SQL databases. ATM supports memory, SQL and Redis and provides sets, queues and many types of maps – from André Bires @andrebires via Take.net @Takenet.

OH Tomstorygo @tomstorygo > #Redis #Failover Win!