Remove Context, use Logger everywhere instead (#70)

We have an internal `typealias Context = Logging.Logger`. This is quite confusing. Remove the typealias, use logger everywhere instead.

Author: fabianfett

Sources/RediStack/ConnectionPool/ConnectionPool.swift

@@ -2,7 +2,7 @@
 //
 // This source file is part of the RediStack open source project
 //
-// Copyright (c) 2020 RediStack project authors
+// Copyright (c) 2020-2023 RediStack project authors
 // Licensed under Apache License v2.0
 //
 // See LICENSE.txt for license information
@@ -103,13 +103,13 @@ internal final class ConnectionPool {
         minimumConnectionCount: Int,
         leaky: Bool,
         loop: EventLoop,
-        systemContext: Context,
+        backgroundLogger: Logger,
         connectionBackoffFactor: Float32 = 2,
         initialConnectionBackoffDelay: TimeAmount = .milliseconds(100),
         connectionFactory: @escaping (EventLoop) -> EventLoopFuture<RedisConnection>
     ) {
         guard minimumConnectionCount <= maximumConnectionCount else {
-            systemContext.critical("pool's minimum connection count is higher than the maximum")
+            backgroundLogger.critical("pool's minimum connection count is higher than the maximum")
             preconditionFailure("Minimum connection count must not exceed maximum")
         }
 

Sources/RediStack/RedisConnection.swift

@@ -2,7 +2,7 @@
 //
 // This source file is part of the RediStack open source project
 //
-// Copyright (c) 2019-2021 RediStack project authors
+// Copyright (c) 2019-2023 RediStack project authors
 // Licensed under Apache License v2.0
 //
 // See LICENSE.txt for license information
@@ -59,7 +59,7 @@ extension RedisConnection {
 
         var future = client
             .connect(to: config.address)
-            .map { return RedisConnection(configuredRESPChannel: $0, context: config.defaultLogger) }
+            .map { return RedisConnection(configuredRESPChannel: $0, backgroundLogger: config.defaultLogger) }
 
         // if a password is specified, use it to authenticate before further operations happen
         if let password = config.password {
@@ -147,8 +147,8 @@ public final class RedisConnection: RedisClient, RedisClientWithUserContext {
     public var onUnexpectedClosure: (() -> Void)?
 
     internal let channel: Channel
-    private let systemContext: Context
-    private var logger: Logger { self.systemContext }
+    private let backgroundLogger: Logger
+    private var logger: Logger { self.backgroundLogger }
 
     private let autoflush = ManagedAtomic<Bool>(true)
     private let allowPubSub = ManagedAtomic<Bool>(true)
@@ -166,14 +166,14 @@ public final class RedisConnection: RedisClient, RedisClientWithUserContext {
         }
     }
 
-    internal init(configuredRESPChannel: Channel, context: Context) {
+    internal init(configuredRESPChannel: Channel, backgroundLogger: Logger) {
         self.channel = configuredRESPChannel
         // there is a mix of verbiage here as the API is forward thinking towards "baggage context"
         // while right now it's just an alias of a 'Logging.logger'
         // in the future this will probably be a property _on_ the context
-        var logger = context
+        var logger = backgroundLogger
         logger[metadataKey: RedisLogging.MetadataKeys.connectionID] = "\(self.id.description)"
-        self.systemContext = logger
+        self.backgroundLogger = logger
 
         RedisMetrics.activeConnectionCount.increment()
         RedisMetrics.totalConnectionCount.increment()
@@ -224,18 +224,18 @@ extension RedisConnection {
     ///     If a `RedisError` is returned, the future will be failed instead.
     public func send(command: String, with arguments: [RESPValue]) -> EventLoopFuture<RESPValue> {
         self.eventLoop.flatSubmit {
-            return self.send(command: command, with: arguments, context: nil)
+            return self.send(command: command, with: arguments, logger: nil)
         }
     }
 
     internal func send(
         command: String,
         with arguments: [RESPValue],
-        context: Context?
+        logger: Logger?
     ) -> EventLoopFuture<RESPValue> {
         self.eventLoop.preconditionInEventLoop()
 
-        let logger = self.prepareLoggerForUse(context)
+        let logger = self.prepareLoggerForUse(logger)
 
         guard self.isConnected else {
             let error = RedisClientError.connectionClosed
@@ -375,7 +375,7 @@ extension RedisConnection {
 
 extension RedisConnection {
     public func logging(to logger: Logger) -> RedisClient {
-        return UserContextRedisClient(client: self, context: self.prepareLoggerForUse(logger))
+        return UserContextRedisClient(client: self, logger: self.prepareLoggerForUse(logger))
     }
 
     private func prepareLoggerForUse(_ logger: Logger?) -> Logger {
@@ -411,19 +411,19 @@ extension RedisConnection {
         messageReceiver receiver: @escaping RedisSubscriptionMessageReceiver,
         onSubscribe subscribeHandler: RedisSubscriptionChangeHandler?,
         onUnsubscribe unsubscribeHandler: RedisSubscriptionChangeHandler?,
-        context: Context?
+        logger: Logger?
     ) -> EventLoopFuture<Void> {
-        return self._subscribe(.channels(channels), receiver, subscribeHandler, unsubscribeHandler, context)
+        return self._subscribe(.channels(channels), receiver, subscribeHandler, unsubscribeHandler, logger)
     }
 
     internal func psubscribe(
         to patterns: [String],
         messageReceiver receiver: @escaping RedisSubscriptionMessageReceiver,
         onSubscribe subscribeHandler: RedisSubscriptionChangeHandler?,
         onUnsubscribe unsubscribeHandler: RedisSubscriptionChangeHandler?,
-        context: Context?
+        logger: Logger?
     ) -> EventLoopFuture<Void> {
-        return self._subscribe(.patterns(patterns), receiver, subscribeHandler, unsubscribeHandler, context)
+        return self._subscribe(.patterns(patterns), receiver, subscribeHandler, unsubscribeHandler, logger)
     }
 
     private func _subscribe(
@@ -503,12 +503,12 @@ extension RedisConnection {
         return self._unsubscribe(.patterns(patterns), nil)
     }
 
-    internal func unsubscribe(from channels: [RedisChannelName], context: Context?) -> EventLoopFuture<Void> {
-        return self._unsubscribe(.channels(channels), context)
+    internal func unsubscribe(from channels: [RedisChannelName], logger: Logger?) -> EventLoopFuture<Void> {
+        return self._unsubscribe(.channels(channels), logger)
     }
 
-    internal func punsubscribe(from patterns: [String], context: Context?) -> EventLoopFuture<Void> {
-        return self._unsubscribe(.patterns(patterns), context)
+    internal func punsubscribe(from patterns: [String], logger: Logger?) -> EventLoopFuture<Void> {
+        return self._unsubscribe(.patterns(patterns), logger)
     }
 
     private func _unsubscribe(_ target: RedisSubscriptionTarget, _ logger: Logger?) -> EventLoopFuture<Void> {

Sources/RediStack/RedisConnectionPool.swift

@@ -2,7 +2,7 @@
 //
 // This source file is part of the RediStack open source project
 //
-// Copyright (c) 2020 RediStack project authors
+// Copyright (c) 2020-2023 RediStack project authors
 // Licensed under Apache License v2.0
 //
 // See LICENSE.txt for license information
@@ -80,7 +80,7 @@ public class RedisConnectionPool {
             minimumConnectionCount: config.minimumConnectionCount,
             leaky: config.maximumConnectionCount.leaky,
             loop: boundEventLoop,
-            systemContext: config.poolDefaultLogger,
+            backgroundLogger: config.poolDefaultLogger,
             connectionBackoffFactor: config.connectionRetryConfiguration.backoff.factor,
             initialConnectionBackoffDelay: config.connectionRetryConfiguration.backoff.initialDelay,
             connectionFactory: self.connectionFactory(_:)
@@ -257,11 +257,11 @@ extension RedisConnectionPool: RedisClient {
     public var eventLoop: EventLoop { self.loop }
 
     public func logging(to logger: Logger) -> RedisClient {
-        return UserContextRedisClient(client: self, context: self.prepareLoggerForUse(logger))
+        return UserContextRedisClient(client: self, logger: self.prepareLoggerForUse(logger))
     }
 
     public func send(command: String, with arguments: [RESPValue]) -> EventLoopFuture<RESPValue> {
-        return self.send(command: command, with: arguments, context: nil)
+        return self.send(command: command, with: arguments, logger: nil)
     }
 
     public func subscribe(
@@ -275,7 +275,7 @@ extension RedisConnectionPool: RedisClient {
             messageReceiver: receiver,
             onSubscribe: subscribeHandler,
             onUnsubscribe: unsubscribeHandler,
-            context: nil
+            logger: nil
         )
     }
 
@@ -290,33 +290,33 @@ extension RedisConnectionPool: RedisClient {
             messageReceiver: receiver,
             onSubscribe: subscribeHandler,
             onUnsubscribe: unsubscribeHandler,
-            context: nil
+            logger: nil
         )
     }
 
     public func unsubscribe(from channels: [RedisChannelName]) -> EventLoopFuture<Void> {
-        return self.unsubscribe(from: channels, context: nil)
+        return self.unsubscribe(from: channels, logger: nil)
     }
 
     public func punsubscribe(from patterns: [String]) -> EventLoopFuture<Void> {
-        return self.punsubscribe(from: patterns, context: nil)
+        return self.punsubscribe(from: patterns, logger: nil)
     }
 }
 
 // MARK: RedisClientWithUserContext conformance
 extension RedisConnectionPool: RedisClientWithUserContext {
-    internal func send(command: String, with arguments: [RESPValue], context: Logger?) -> EventLoopFuture<RESPValue> {
+    internal func send(command: String, with arguments: [RESPValue], logger: Logger?) -> EventLoopFuture<RESPValue> {
         return self.forwardOperationToConnection(
             { (connection, returnConnection, context) in
 
                 connection.sendCommandsImmediately = true
 
                 return connection
-                    .send(command: command, with: arguments, context: context)
+                    .send(command: command, with: arguments, logger: context)
                     .always { _ in returnConnection(connection, context) }
             },
             preferredConnection: nil,
-            context: context
+            context: logger
         )
     }
 
@@ -325,7 +325,7 @@ extension RedisConnectionPool: RedisClientWithUserContext {
         messageReceiver receiver: @escaping RedisSubscriptionMessageReceiver,
         onSubscribe subscribeHandler: RedisSubscriptionChangeHandler?,
         onUnsubscribe unsubscribeHandler: RedisSubscriptionChangeHandler?,
-        context: Context?
+        logger: Logger?
     ) -> EventLoopFuture<Void> {
         return self.subscribe(
             using: {
@@ -334,24 +334,24 @@ extension RedisConnectionPool: RedisClientWithUserContext {
                     messageReceiver: receiver,
                     onSubscribe: subscribeHandler,
                     onUnsubscribe: $1,
-                    context: $2
+                    logger: $2
                 )
             },
             onUnsubscribe: unsubscribeHandler,
-            context: context
+            context: logger
         )
     }
 
-    internal func unsubscribe(from channels: [RedisChannelName], context: Context?) -> EventLoopFuture<Void> {
-        return self.unsubscribe(using: { $0.unsubscribe(from: channels, context: $1) }, context: context)
+    internal func unsubscribe(from channels: [RedisChannelName], logger: Logger?) -> EventLoopFuture<Void> {
+        return self.unsubscribe(using: { $0.unsubscribe(from: channels, logger: $1) }, context: logger)
     }
 
     internal func psubscribe(
         to patterns: [String],
         messageReceiver receiver: @escaping RedisSubscriptionMessageReceiver,
         onSubscribe subscribeHandler: RedisSubscriptionChangeHandler?,
         onUnsubscribe unsubscribeHandler: RedisSubscriptionChangeHandler?,
-        context: Context?
+        logger: Logger?
     ) -> EventLoopFuture<Void> {
         return self.subscribe(
             using: {
@@ -360,22 +360,22 @@ extension RedisConnectionPool: RedisClientWithUserContext {
                     messageReceiver: receiver,
                     onSubscribe: subscribeHandler,
                     onUnsubscribe: $1,
-                    context: $2
+                    logger: $2
                 )
             },
             onUnsubscribe: unsubscribeHandler,
-            context: context
+            context: logger
         )
     }
 
-    internal func punsubscribe(from patterns: [String], context: Context?) -> EventLoopFuture<Void> {
-        return self.unsubscribe(using: { $0.punsubscribe(from: patterns, context: $1) }, context: context)
+    internal func punsubscribe(from patterns: [String], logger: Logger?) -> EventLoopFuture<Void> {
+        return self.unsubscribe(using: { $0.punsubscribe(from: patterns, logger: $1) }, context: logger)
     }
 
     private func subscribe(
-        using operation: @escaping (RedisConnection, @escaping RedisSubscriptionChangeHandler, Context) -> EventLoopFuture<Void>,
+        using operation: @escaping (RedisConnection, @escaping RedisSubscriptionChangeHandler, Logger) -> EventLoopFuture<Void>,
         onUnsubscribe unsubscribeHandler: RedisSubscriptionChangeHandler?,
-        context: Context?
+        context: Logger?
     ) -> EventLoopFuture<Void> {
         return self.forwardOperationToConnection(
             { (connection, returnConnection, context) in
@@ -406,8 +406,8 @@ extension RedisConnectionPool: RedisClientWithUserContext {
     }
 
     private func unsubscribe(
-        using operation: @escaping (RedisConnection, Context) -> EventLoopFuture<Void>,
-        context: Context?
+        using operation: @escaping (RedisConnection, Logger) -> EventLoopFuture<Void>,
+        context: Logger?
     ) -> EventLoopFuture<Void> {
         return self.forwardOperationToConnection(
             { (connection, returnConnection, context) in
@@ -430,9 +430,9 @@ extension RedisConnectionPool: RedisClientWithUserContext {
 
     @usableFromInline
     internal func forwardOperationToConnection<T>(
-        _ operation: @escaping (RedisConnection, @escaping (RedisConnection, Context) -> Void, Context) -> EventLoopFuture<T>,
+        _ operation: @escaping (RedisConnection, @escaping (RedisConnection, Logger) -> Void, Logger) -> EventLoopFuture<T>,
         preferredConnection: RedisConnection?,
-        context: Context?
+        context: Logger?
     ) -> EventLoopFuture<T> {
         // Establish event loop context then jump to the in-loop version.
         guard self.loop.inEventLoop else {