:sparkles: decreased processor time and removed echos in code

docker-compose.yml

···
     deploy:
       resources:
         limits:
-          cpus: "0.1"
+          cpus: "0.15"
           memory: "30MB"
     volumes:
       - redis-data:/data
 
-  api1: &app
+  api1: &app # image: pedrohcorrea/rinha-backend-2025-gleam:latest
     build:
       context: .
     container_name: api1
···
     environment:
       REDIS_CONN: valkey
       PROVIDERS: "http://payment-processor-default:8080,http://payment-processor-fallback:8080"
-      PROCESSOR_QTT: 1
-      PROCESSOR_TIME: 50
+      PROCESSOR_TIME: 40
     depends_on:
       - valkey
     deploy:
       resources:
         limits:
-          cpus: "1"
-          memory: "255MB"
+          cpus: "0.8"
+          memory: "235MB"
 
   api2:
     <<: *app
     container_name: api2
     environment:
       REDIS_CONN: valkey
-      PROVIDERS:
     deploy:
       resources:
         limits:
-          cpus: "0.3"
-          memory: "55MB"
+          cpus: "0.4"
+          memory: "75MB"
 
   nginx:
     image: nginx:1.29.0-alpine
···
     deploy:
       resources:
         limits:
-          cpus: "0.1"
+          cpus: "0.15"
           memory: "10MB"
 
 volumes:

src/processor.gleam

···
       actor.continue(state)
     }
     HealthCheck -> {
-      echo "Healthcheck"
       let provider =
         get_faster_healthcheck(state.providers, state.selected_provider)
 
···
 
   let body_to_send = message |> provider.create_body
 
-  echo "Sending request to " <> processor.selected_provider.url
   case provider.send_request(processor.selected_provider, body_to_send) {
     Ok(_) -> {
       message

src/rinha_2025.gleam

···
 import gleam/int
 import gleam/list
 import gleam/otp/static_supervisor as supervisor
-import gleam/otp/supervision
 import gleam/string
 import integrations/provider
 import processor
···
   let providers_env = util.get_env_var("PROVIDERS", "")
   let assert Ok(processor_time) =
     util.get_env_var("PROCESSOR_TIME", "100")
-    |> int.parse
-  let assert Ok(processor_qtt) =
-    util.get_env_var("PROCESSOR_QTT", "0")
     |> int.parse
 
   let providers =
···
     redis.create_supervised_pool(redis_host)
   let valky = valkyrie.named_connection(valkey_pool_name)
 
+  let ctx = server.Context(valkye_conn: valky)
+
+  use <- bool.lazy_guard(when: has_providers == False, return: fn() {
+    let assert Ok(_) =
+      supervisor.new(supervisor.OneForOne)
+      |> supervisor.add(valkey_pool)
+      |> supervisor.add(web.create_server_supervised(ctx))
+      |> supervisor.start
+
+    process.sleep_forever()
+  })
+
   let worker_name = process.new_name("worker_pool")
   let worker_pool_supervised =
     processor.new(valky)
     |> processor.named(worker_name)
     |> processor.providers(providers)
     |> processor.supervised
-
-  let ctx = server.Context(valkye_conn: valky)
 
   let assert Ok(_) =
     supervisor.new(supervisor.OneForOne)
     |> supervisor.add(valkey_pool)
     |> supervisor.add(web.create_server_supervised(ctx))
-    |> create_supervisor_with_processor(worker_pool_supervised, has_providers)
+    |> supervisor.add(worker_pool_supervised)
     |> supervisor.start
 
-  use <- bool.lazy_guard(when: !has_providers, return: process.sleep_forever)
-
-  list.repeat(Nil, processor_qtt)
-  |> list.map(fn(a) {
-    process.spawn(fn() {
-      worker_name
-      |> process.named_subject
-      |> processor.loop_worker(processor_time)
-    })
-    a
+  process.spawn(fn() {
+    worker_name
+    |> process.named_subject
+    |> processor.loop_worker(processor_time)
   })
 
   process.spawn(fn() {
···
 
   process.sleep_forever()
 }
-
-fn create_supervisor_with_processor(
-  manager: supervisor.Builder,
-  processor: supervision.ChildSpecification(process.Subject(processor.Message)),
-  has_processor: Bool,
-) {
-  use <- bool.guard(when: !has_processor, return: manager)
-
-  manager
-  |> supervisor.add(processor)
-}

src/web/controllers/payment_controller.gleam

···
     |> list.wrap
 
   let assert Ok(_) =
-    echo ctx.valkye_conn
-      |> redis.enqueue_payments(data_to_insert)
+    ctx.valkye_conn
+    |> redis.enqueue_payments(data_to_insert)
 
   wisp.no_content()
 }

src/web/middleware.gleam

···
 ) -> wisp.Response {
   let req = wisp.method_override(req)
 
+  use <- wisp.log_request(req)
   use <- wisp.rescue_crashes
   use req <- wisp.handle_head(req)
 

src/web/web.gleam

···
 import mist
 import web/router
 import web/server
+import wisp
 import wisp/wisp_mist
 
 pub fn create_server_supervised(ctx: server.Context) {
+  wisp.configure_logger()
+
   router.handle_request(_, ctx)
   |> wisp_mist.handler("secret")
   |> mist.new