Adjust when some runtime deprecation notices are triggered and use Symfony's `trigger_deprecation()` helper

[mbabker]

Q	A
Bug fix?	yes
New feature?	no
BC breaks?	no
Deprecations?	no
Related tickets	fixes #448
License	MIT

This PR will do two things:

1. Adjusts when some runtime deprecations (especially for those which are unfixable in consuming applications) to be triggered when the deprecated element is actually used instead of arbitrarily emitting them when the file is loaded
2. Uses Symfony's trigger_deprecation() helper for runtime deprecations; this is designed to be a "pluggable" function that can allow someone to customize the functionality in their applications if so desired (plus the function's signature forces key information at the front of each message which makes scanning the messages a bit better IMO)

[mccraigmccraig]

we (yapster) are using aleph via juxt/yada

we have an http rest/json api, and also use websockets quite a lot. we do multipart upload with the implementation that yada provides. we're heavy users of manifold deferreds and streams

[edit] oops - we use the http client a fair bit too

[gsnewmark]

We're using following pieces of Aleph at Attendify:

• HTTP client: mostly internal inter-service communication, as well as using REST APIs of internal data storages
• HTTP server: both internal services and public-facing APIs (a variant of JSON-RPC in both cases)
• Multipart support
• WebSockets (only for the internal chatbot)

We've also tried proxy support in the HTTP client, but not using it in production yet.

Not directly connected to Aleph, but quite a lot of our code also uses Manifold's deferred to define async operations. We're not using streams that much though.

Edit: corrected usage of WebSockets.

[piranha]

Kasta uses Aleph for the following:

• HTTP server: our web servers use Aleph.
• HTTP client: we have some (not much) internal communication through HTTP APIs, where we use Aleph as client (together with multipart support).
• Websockets: public service, where we provide current information on product stocks. Every client (be it web or app) opens a connection to websockets, so they sustain some load.

[danielcompton]

Deps (private Maven repository hosting) is using Aleph for the main web application and handling uploads. Downloads go through Varnish. All of the usage of Aleph is via juxt/yada which also makes heavy use of Manifold.

Our use is pretty basic, just an HTTP server, no web sockets or HTTP client.

[jhimanka]

Priima LMS uses Aleph as a ring-compatible HTTP server. Pretty basic functionality now but we are looking into asynchronous cases and Manifold.

[wzimrin]

organizetogether.com is using the aleph web server as our main web sever, and all of our server code is built around manifolds. We're also using the aleph http client to talk to external services whenever reasonable (mostly because it uses manifolds). We're using sente and sente's aleph adaptor for websockets.

In practice, our server code is built around manifolds, then we convert the resulting manifold-based handler to a cps style so we can use ring middleware, and then we convert the cps style handler back into a manifold based one in order to pass it to aleph. It works, but the result feels a tad clunky.

[jcf]

A number of companies and clients I’ve worked with use the Aleph HTTP client and Manifold in production, and a small number of clients used Yada (which as already mentioned is built on top of Aleph).

Aleph and Manifold will play a role in some of my upcoming work, and I’m happy to discuss some of the details privately if that would be helpful.

[ztellman]

@jcf feel free to contact me with any details you're not comfortable sharing publicly

[scramjet]

Systematic is using Aleph in production for both client websocket connections, and for serving web pages at signup (+ Ring + Hiccup + Garden).

We're making active use of Aleph's async request/response support in Ring, and Manifold's integration with core.async (most of our async logic is in core.async, although we'll likely experiment with using Manifold directly at some point).

In future, we'll likely also use Aleph for providing a B2B REST API for our clients.

We love Aleph for many reasons, but it's especially nice for us because we already have a heavy investment in Netty for our other backend services (APNs, DNS, etc).

[jaju]

I'm using the http part for a client that is in "soft" production mode right now. (Can't reveal the name, but will ask). I expect to use manifold soon in another part.

[danjohansson]

KPSystem in Sweden is using the following Aleph functionality: webserver, client, websockets and multipart. We are very happy with it!

[alexander-yakushev]

Grammarly uses Aleph in a part of its backend stack. Things used substantially: HTTP server, HTTP client, asynchronous flows with Manifold, fine-tuned and monitored executors and pools.

[pyr]

Hi!

After a detour through some direct Netty interaction - mostly as a learning exercice - Exoscale now defaults to aleph and manifold for the following in Clojure:

• RPC servers and clients
• HTTP servers and clients
• Most database clients
• The up & coming exoscale api client library in Clojure is purely async thanks to aleph and manifold for instance.

Thanks a lot for your work!

[rborer]

Finity.ai is using Aleph for our internal counters & events component. Aleph HTTP server is used there, responding to roughly 7.5 million requests per day.

We also have started work to transition our web crawler (crawling ~ 26 million URLs per day) from our venerable internal Netty 3.10 wrapper into Aleph. It's a long process as I realized that our current execution model had a few quirks. It's currently running on our testing infrastructure and I intend to deploy it to production beginning next year (I still have to figure out why it gives an OOM every few days of runtime...).

We're also relying a lot on manifold for our whole stream processing platform (which is really awesome btw!).

[superstructor]

@flybot-sg (Flybot Ltd, Singapore) is using it for our HTTP+WebSocket APIs for all sorts of multiplayer game services. Clients are built with the Unity game engine.

[fmnoise]

Eventum (https://eventum.no) is using Aleph for HTTP(servers and clients) and SSE. We also use Manifold for async flows.

[lvh]

We (Latacora) use Aleph/Manifold for some software that talks to AWS a bunch. (It's not a particularly judicious use of Aleph, since it's all blocking AWS SDK goop under the hood.)

[jeroenvandijk]

At adgoji, we're using the Aleph http server as the main http endpoint of our realtime bidder, running on 50-100 servers.

We use Engulf, an application that is build upon (an older version of) Aleph, for load testing. We are using yada in several of our internal endpoints. We use manifold in a lot of our async code as it is more composable than core.async.

[miikka]

At Metosin, I'm using Aleph in one project (a SaaS application) as the HTTP server and I've written some HTTP API clients with it as well.

[dev-smx]

Smxemail uses Aleph for our internal HTTP APIs to the components of our email archive and analytics products running on Azure.

[csm]

At Noon Home we use Aleph in a number of publicly-facing and internal HTTP services; we also use the HTTP client for communication between services. We use the TCP server, with TLS, for all communication with our devices in the field, and use TCP client and server for an internal message queue we developed in-house.

To expand a bit:

• Our public and internal HTTP servers are RESTful services, and they serve mostly very small requests/responses (JSON, and some GraphQL and MessagePack). We use compojure-api with a handful of hacks to let us do async responses. We front these with load balancers in AWS (terminating HTTPS at the load balancer).
• Our HTTP client usage is internal, using some of the above RESTful APIs.
• Our TCP services (device-facing and message queue) are both custom binary protocols. We leverage some Netty internals here, to do things like message framing. We formerly used gloss but migrated off that some time ago.

[aengelberg]

At Amperity we:

• use the Aleph HTTP server for our externally-facing microservices, wrapped with Yada to give us routing and some more HTTP features for free.
  • largely dealing with small payloads, but we have a couple of file-upload endpoints that exercise Aleph's streaming capabilities and parse multi-part form data.
• batch-load data to/from various external APIs with the Aleph HTTP client.
• use Manifold deferreds and async composition religiously around the codebase, even for our internal microservices which are backed by finagle-clojure, not Aleph.

[bostonaholic]

At CircleCI, we use it in a few different services. As of yet, we are utilizing only aleph.http/start-server for some internal and externally exposed services. Routing handled by ring and compojure.

[shayanjm]

We use Aleph at Watchful to power our RESTful API and SSE streaming interfaces!

[loomis]

SixSq uses Aleph for its core ring handler in its (micro) services. We also indirectly use the client indirectly through the kvlt library. As kvlt is deprecated, we will likely use the Aleph client directly in the future. We use the streaming features of Aleph via SSE in some parts of our RESTful APIs.

[tanzoniteblack]

At Yummly, we use aleph (via yada) for the API responses that drive our smart oven & app integration (Whirlpool new release on this), but currently don't actively use it to make http requests or to serve the traffic that runs our website (we use http-kit for that).

We are, however, starting to become very heavy users of manifold in our main API.

[mrijk]

VakantieDiscounter uses Aleph (as http client) mostly for async calls to our internal API's, as well as asynchronous flows with Manifold.

[bhurlow]

We use Aleph at yellowdig for general HTTP server needs, as well as streaming for large data sets

[rgm]

Using aleph with ring/reitit at opengb for some fairly straightforward SPA backends.

[JarredLHumphrey]

We use Aleph at Adaptly (recently acquired by Accenture) as an http client for high volume requests to 3rd party apis.