AFAIK that variant is only applicable to Promises and Futures (that block if not delivered/realised) but I use it quite a lot on Promises in testing async functions to prevent tests blocking forever.

You're right. It's only useful when there is a blocking operation involved. Atoms and Agents are not blocking access to a state. I just didn't know about this arity to exist until I was reading clojure source code. That's why reading (other people) code matters 🙂

What does “ROS” mean? ☺️

Is it this? https://www.ros.org

Yes 😅

Cool! I don't know anything about that. I was just curious what it meant 😄

I tried adding some middleware like this:

{:name    ::format-request
                               :spec    ::spec
                               :compile (fn [ctx ctx2]
                                          (log/log-map :error nil nil "str" {:ctx ctx :ctx2 ctx2})
                                          {:wrap (fn [x] (println (str "str" {:ctx3 x})) x)})}

Why not instrument the server's thread pool?

sure, how do I do that? using jetty

If you look at the executor service constructor, you can pass it a queue. Wrap it and inc counters for add and remove

I'd do it with reify into the queue interface

Iirc jetty lets you pass your own executor service, right?

I don’t know, but I will check, thx!

is putting a gauge on the default threadpool ok in your opinion?

(.getIdleThreads (.getThreadPool server))
(.getThreads (.getThreadPool server))

Why not have two counters, for takes and puts? That encompasses all the information you need, no?

decided to go with both. got a gauge and a counter (dec and inc). the gauge feels more “right” cause I don’t need to wrap stuff. the counter feels more “right” since it is always “right” and you don’t have to call some function to fetch it. will see what I decide 😄

Counters are simpler. Also, when you have two, you can compare your ingress rate and your processing rate

I have timers there too, should do the trick, right?

Too much 😄 If you have a counter, the derivative gives you rate I don't see why you need anything besides two counters

Although you can time the processing duration at the pool

Though you can't guarantee your task finishes on the pool or on another pool

went with both for now, will update how it goes 🙂

I would load a json / edn

@U031X1BLY5U, How would you load the variables from EDN into the environment/REPL? I thought there might be some de facto standard Clojure library that takes care of that.

you can keep doing the same and read secrets from environment variables. (System/getenv "VAR_NAME")

jsonista could read it for you

that also mean you have to prepare your environment in production. eg. load .env file before running uberjar

My favorite way of dealing with configuration until now has been juxt/aero, which gives you edn with some useful reader tags, such as environment variables, string interpolation and profiles. You can also include local files

That way you can have a local file with private settings and a production file as part of a repository

You can take a look at this implementation https://github.com/spapas/ringu/tree/master/src/ringu/conf

There are some libraries that do something similar. But as others have said, I think using configuration is better as well. Simply put, don't use environment variables, instead have a config file with secrets in them, could be EDN, and load that. Then when you deploy, you push a similar config file onto your machine where the file only has permissions to be read by the user that is running your application.

Or, if you prefer using environment variables, even though I think it's less secure, you can have a .env file in edn format and write yourself something simple like:

(defn get-env
  [k]
  (or (System/getenv k) (get (edn/read-string (slurp ".env")) k))

Thanks for all your advice! I'll probably go for the EDN config file approach instead of environment variables. But I'll check out those other ideas and links as well.

@U01PE7630AC I bumped into this while working through some compojure tutorials: https://github.com/weavejester/environ

I think someone already mentioned juxt/aero, but I think they have it pretty well figured out for managing config and secrets

For secrets, you can use services like AWS Secrets Manager

https://github.com/yogthos/config has been dealing with my env variables for quite some time.

Looks sensible to me, though there are a few tricks you might (or not) wish to use.

First, it's idiomatic to use a set as a predicate: instead of (map #(contains? allowed-tags %) tags), you can instead write (map allowed-tags tags).

I'm still new, so if this not idiomatic or correct please correct me. But instead of the some and map construction, you could just do a subset check:

(subset? tags allowed-tags)

Using allowed-tags as a function will return the tag in question or nil, if not found in the set.

I'd consider something like the following pretty idiomatic:

(when (seq (remove allowed-tags tags))
  (throw (Exception. "Specified tags are not allowed")))

Any reason to prefer that over my subset solution? 🙂 I personally think that more clearly states intent

clojure.set/subset? does convey the intention very well! I think the only drawback is that one really ought to use the function with sets, not collections of a generic kind.

For instance, subset? internally calls clojure.core/contains? which will not perform a linear search:

(contains? [:b :c :d] :d)
=> false

Thanks, learned something valuable there!

You could do it slightly more readable with doseq (I think):

(defn ensure-correct-tagging [tags]
  (doseq [tag tags]
    (when-not (some #(= tag %) allowed-tags)
      (throw (Exception. "Specified tags are not allowed")))))

Thank you all very much for the reply 🙂 All suggested solutions look much better

@UCYS6T599 Do I understand correctly that this would work properly?

(subset? (set tags) allowed-tags)

Yup, looks good to me!

@U03BYUDJLJF it assumes that the arguments are sets. It won't work for anything else though, so that would cause all kinds of issues if one of the arguments is not a set. Also (set nil) would always match, that may be a side effect you might not want?

Yeah as pyry explained it's not guaranteed to work unless the inputs are sets indeed. That's why I changed tags to (set tags) in my later solution. Good point about the (set nil) , I didn't think about that

I happened to write an append transducer, not too complicated, though I might have an error https://github.com/bsless/fast.csv/blob/master/src/bsless/fast/csv.clj#L96

yea I guess I need to write something like this myself :thinking_face:

ok ([result] (rf (rf result sep))) seems very straight forward 😄

Yeah, but you should probably check reduced before

Oh yea I always wonder that myself, when to check for it 🙈

Guess you could also consider using a deque or a finger tree instead?

that sounds… more advanced than I need it ^^

Fair enough. 🙂

yea, will try it out and share the results where I ended up 😄

I guess this should do the trick

(defn append
  "Transducer which continues with a collection of values if completion is reached."
  [^Collection coll]
  (fn [step]
    (let [reduced-preserving-step #(let [ret (step %1 %2)]
                                     (if (reduced? ret)
                                       (reduced ret)
                                       ret))]
      (fn
        ;; init
        ([] (step))
        ;; completion
        ([result] (step (reduce reduced-preserving-step result coll)))
        ;; perform step
        ([result input] (step result input))))))

(defn prepend
  "Transducer which prepends a collection of values as the leading results until exhausted."
  [^Collection coll]
  (fn [step]
    (let [reduced-preserving-step #(let [ret (step %1 %2)]
                                     (if (reduced? ret)
                                       (reduced ret)
                                       ret))
          consumed?               (volatile! false)]
      (fn
        ;; init
        ([] (step))
        ;; completion
        ([result] (step result))
        ;; perform step
        ([result input]
         (if @consumed?
           (step result input)
           (do
             (vreset! consumed? true)
             (step (reduce reduced-preserving-step result coll) input))))))))

FYI @UK0810AQ2