Node-redis: retry_strategy에서 반환된 오류는 여전히 포착되지 않습니다.

@pavelsc 나는 이것을 재현하려고 시도했지만 지금까지는 할 수 없었습니다.

타사 모듈 없이 문제를 재현해 보십시오. 현재 최소한 q 사용하는 것 같습니다.

같은 오류가 발생했습니다. 의도적으로 Redis 클라이언트에 잘못된 URL을 제공하면 on.error 메서드가 호출되지 않습니다. 다음은 간단한 예입니다.

var redis = require("redis");

exports.handler = function (event, context, callback) {

    console.log("Executing test lambda for diagnosing redis issues");

    var redisInfo = {
        HOST: process.env.REDIS_HOST,
        PORT: process.env.REDIS_PORT
    };

    console.log(process.env.REDIS_HOST);
    console.log(process.env.REDIS_PORT);

    console.log("Connecting to Redis...");

    var client = redis.createClient({
        host: redisInfo.HOST,
        port: redisInfo.PORT,
        retry_strategy: function (options) {

            if (options.total_retry_time > 2000) {
                console.log("throwing an error...");
                return new Error('Retry time exhausted');
            }

            return 200;
        }
    });

    // if you'd like to select database 3, instead of 0 (default), call
    // client.select(3, function() { /* ... */ });

    client.on("error", function (err) {
        console.log("Error " + err);
        callback(null, "Error with Redis");
    });

    client.on('connect', function() {
        console.log("Connected to Redis");
    });

    client.on('end', function() {
        console.log("Redis end");
    });

    client.set("string key", "string val", redis.print);
    client.hset("hash key", "hashtest 1", "some value", redis.print);
    client.hset(["hash key", "hashtest 2", "some other value"], redis.print);
    client.hkeys("hash key", function (err, replies) {
        console.log(replies.length + " replies:");
        replies.forEach(function (reply, i) {
            console.log("    " + i + ": " + reply);
        });
        client.quit();
    });

    client.quit();

    callback(null, "Success");
};

지금은 연결 제한 시간이 만료된 후 올바르게 '오류'가 발생하는 connect_timeout을 사용하도록 되돌리고 있습니다.

동일한 문제가 있습니다. 잘못된 끝점이 있는 사용자 지정 retry_strategy를 사용하면 "AbortError:"가 발생합니다.

이것은 오늘도 나를 사로잡았다. 코드를 간단히 살펴보면 이것은 의도적인 동작으로 보입니다. https://github.com/NodeRedis/node_redis/blob/79558c524ff783000a6027fb159739770f98b10e/index.js#L405 는 retry_strategy 가 설정되면 오류를 내보내지 않고 대신 계속 던진다고 명시적으로 명시하고 있습니다. 왜 이러는지 궁금하긴 한데, 휙휙 던진다기 보다는 발산하지 못하는 이유가 없는 것 같습니다. 이 조건문이 제거되지 않아 항상 오류가 발생하는 이유가 있습니까?

저도 이 문제를 지속적으로 겪고 있습니다.

나도 ENOTFOUND 받을 때 오류를 잡을 수 없습니다.

{
    host: "foo",
    retry_strategy: function (options) {
        if (options.error && options.error.code === "ENOTFOUND") {
            return new Error("The server was not found");
        }

        // reconnect after
        return 1000;
}

와 함께:

redis.on("error", err => {
    console.error("Cache Error: " + err);
});

응용 프로그램을 디버깅할 때 retry_strategy 에서 위에서 언급한 대로 ENOTFOUND 검사에 들어가고 있지만 오류 이벤트 처리기를 호출하지 않습니다.

동일한 문제가 있습니다. 소스 코드를 조사한 후 변경하면
이 줄(또는 디버그 모드 활성화)
https://github.com/NodeRedis/node_redis/blob/009479537eb920d2c34045026a55d31febd1edd7/index.js#L381 -L382

그리고 여기에 이 ​​코드를 삽입하십시오(즉시 배열에 오류를 추가하십시오)
https://github.com/NodeRedis/node_redis/blob/009479537eb920d2c34045026a55d31febd1edd7/index.js#L352 -L353

    if (options.error) {
      aggregated_errors.push(options.error);
    }

제대로 작동하고 '오류'가 발생합니다.

해당 함수의 중첩 루프는 실행되지 않습니다. 'command_queue'가 비어 있고 error never get이 배열에 추가되어 방출되지 않기 때문입니다. 내가 올바르게 이해한다면 꽤 오래된 코드이므로 유지 관리자 또는 @BridgeAR의 입력이 필요합니다.

나는 또한 첫 번째 실패한 연결에서 'end' 이벤트를 내보내는 것을 보았습니다. 이는 무언가를 의미할 수 있습니다(또는 그렇지 않을 수도 있음). 이틀 전에 Redis를 집어 들었기 때문에 내부가 아직 어떻게 작동하는지 잘 모르겠습니다. 시간이 있을 때 포크하고 조금 더 파헤쳐보려고 합니다.

그리고 말 그대로 다음 문제는 이 문제 #1198과 연결된 것 같습니다.

@v1adko 저는 현재 여행 중이지만 오늘이나 내일(Ruben이 저를

오류 시나리오를 테스트하기 위해 의도적으로 잘못된 redis URL이 있지만 redis에 연결하려고 할 때 retry_strategy가 호출되지 않는 것을 봅니다. retry_strategy는 연결이 닫힐 때만 호출됩니다.

`const redis = require('redis');
const 로그 = require('./logUtil').logger;

module.exports.connect = () => {

var redisRetryStrategy = function(options) {
    if (options.error && options.error.code === 'ECONNREFUSED') {
        // End reconnecting on a specific error and flush all commands with 
        // a individual error
        log.error('The redis server refused the connection');
        return new Error('The redis server refused the connection');
    }

    log.info(`Already spent ${options.total_retry_time} milliseconds to re-establish connection with redis`);
    if (options.total_retry_time > 2000) {
        // End reconnecting after a specific timeout and flush all commands 
        // with a individual error 
        log.error('Retry time exhausted');
        return new Error('Retry time exhausted');
    }
    log.info(`Attempting ${options.attempt} time to establish connection with redis`);
    if (options.attempt > 5) {
        // End reconnecting with built in error 
        log.error('Exhausted the retry attempts to establish connection to redis');
        return undefined;
    }
    // reconnect after 
    return 100;
}


log.info(`Redis connection url is :${process.env.REDIS_URL}`);
var redisClient = redis.createClient(qualifyUrl(process.env.REDIS_URL), {
    retry_strategy: redisRetryStrategy
});

redisClient.offline_queue_length = 3;

redisClient.on('connect', function() {
    console.log('Connected to Redis');
});

redisClient.on('reconnecting', function() {
    console.log('Re-Connecting to Redis');
});

redisClient.on('error', (err)=> {
    console.log(`Error trying to create redis connection: ${JSON.stringify(err)}`);
});
return redisClient;

}

const qualifyUrl = (URL) => {
return '//' + url.replace(/^\/+/,"");
};

`

누군가가이 문제를 해결하는 데 도움을 줄 수 있습니까?

여기도 마찬가지입니다. 이 불쾌한 해킹은 예상되는 동작을 생성하는 것 같지만 더 넓은 의미가 있는지 확실하지 않습니다.

const client = redis.createClient({
  retry_strategy: ({error}) => client.emit('error', error)
});

client.on('error', console.error);

나는 현재 같은 문제를 겪고 있습니다. retry_strategy를 사용하여 Readme의 예제에 표시된 대로 오류를 반환하지만 클라이언트에서 오류가 발생하지 않습니다. @v1adko가 제안한 수정 사항은 적어도 액면 그대로 문제를 해결합니다.

여기에 언급된 이전 버전과의 비호환성이 무엇인지 궁금합니다.
https://github.com/NodeRedis/node_redis/blob/009479537eb920d2c34045026a55d31febd1edd7/index.js#L380

@maael이 지적한 것처럼 동작은 retry_strategy가 설정된 경우 의도적인 것으로 보입니다. 예상되는 동작이지만 문서가 올바르지 않습니까? @c24w에서 제안한 대로 수동으로 클라이언트에 대한 오류를 내

편집: 패키지를 파헤치면서 수동으로 방출하는 것이 아마도 앞으로 나아갈 길이 아니라는 것을 깨닫고 있습니다. 언급된 주요 변경 사항을 이해해야 하는 것 같습니다.

어떤 소식이 있습니까? 나는 같은 문제를 가지고있다.

소식이 있나요?

하는 것은 잘못된 생각입니다.
js if (options.error && options.error.code === 'ECONNREFUSED') { // End reconnecting on a specific error and flush all commands with // a individual error return Math.min(options.attempt * 100, 3000); }

동일한 문제가 있는데 retry_Strategy가 오류 이벤트를 트리거하지 않고 아직 수정되지 않았습니까?

성공하신 분 계신가요?

대신 구현을 https://github.com/luin/ioredis 로 전환하여 몇 가지 개선 사항을 가져왔습니다(네이티브 Promises, lazyConnect(redis 클라이언트를 인스턴스화할 때 연결을 열지 않고 필요한 위치에서 오류를 정확하게 처리하는 데 도움이 됨)). 다음 코드를 실행할 수 있습니다.

let cachedItem;

  try {
    logger.debug(`Fetching GraphCMS query in redis cache...`);
    // XXX If fetching data from redis fails, we will fall back to running the query against GraphCMS API in order to ensure the client gets the data anyway
    cachedItem = await redisClient.get(body);
  } catch (e) {
    logger.debug(`An exception occurred while fetching redis cache.`);
    logger.error(e);
    epsagon.setError(e);
  }

다음 utils/redis.js :

import { createLogger } from '@unly/utils-simple-logger';
import Redis from 'ioredis';
import epsagon from './epsagon';

const logger = createLogger({
  label: 'Redis client',
});

/**
 * Creates a redis client
 *
 * <strong i="11">@param</strong> url Url of the redis client, must contain the port number and be of the form "localhost:6379"
 * <strong i="12">@param</strong> password Password of the redis client
 * <strong i="13">@param</strong> maxRetriesPerRequest By default, all pending commands will be flushed with an error every 20 retry attempts.
 *          That makes sure commands won't wait forever when the connection is down.
 *          Set to null to disable this behavior, and every command will wait forever until the connection is alive again.
 * <strong i="14">@return</strong> {Redis}
 */
export const getClient = (url = process.env.REDIS_URL, password = process.env.REDIS_PASSWORD, maxRetriesPerRequest = 20) => {
  const client = new Redis(`redis://${url}`, {
    password,
    showFriendlyErrorStack: true, // See https://github.com/luin/ioredis#error-handling
    lazyConnect: true, // XXX Don't attempt to connect when initializing the client, in order to properly handle connection failure on a use-case basis
    maxRetriesPerRequest,
  });

  client.on('connect', function () {
    logger.info('Connected to redis instance');
  });

  client.on('ready', function () {
    logger.info('Redis instance is ready (data loaded from disk)');
  });

  // Handles redis connection temporarily going down without app crashing
  // If an error is handled here, then redis will attempt to retry the request based on maxRetriesPerRequest
  client.on('error', function (e) {
    logger.error(`Error connecting to redis: "${e}"`);
    epsagon.setError(e);
  });

  return client;
};

그리고 utils/redis.test.js 파일:

import { getClient } from './redis';

let redisClient;
let redisClientFailure;

describe('utils/redis.js', () => {
  beforeAll(() => {
    redisClient = getClient();
    redisClientFailure = getClient('localhost:5555', null, 0); // XXX This shouldn't throw an error because we're using lazyConnect:true which doesn't automatically connect to redis
  });

  afterAll(async () => {
    await redisClient.quit();
    await redisClientFailure.quit();
  });

  describe('should successfully init the redis client', () => {
    test('when provided connection info are correct', async () => {
      // Environment variables are from the .env.test file - This tests a localhost connection only
      expect(redisClient.options.host).toEqual(process.env.REDIS_URL.split(':')[0]);
      expect(redisClient.options.port).toEqual(parseInt(process.env.REDIS_URL.split(':')[1], 10));
      expect(redisClient.options.password).toEqual(process.env.REDIS_PASSWORD);
    });

    test('when connection info are incorrect', async () => {
      expect(redisClientFailure.options.host).toEqual('localhost');
      expect(redisClientFailure.options.port).toEqual(5555);
    });
  });

  describe('should successfully perform native operations (read/write/delete/update)', () => {
    test('when using async/await (using native node.js promises)', async () => {
      const setResult = await redisClient.set('key-1', 'value-1');
      expect(setResult).toEqual('OK');

      const result = await redisClient.get('key-1');
      expect(result).toEqual('value-1');

      const delResult = await redisClient.del('key-1');
      expect(delResult).toEqual(1);

      const setResultB = await redisClient.set('key-1', 'value-1b');
      expect(setResultB).toEqual('OK');

      const resultB = await redisClient.get('key-1');
      expect(resultB).toEqual('value-1b');

      const setResultC = await redisClient.set('key-1', 'value-1c');
      expect(setResultC).toEqual('OK');

      const resultC = await redisClient.get('key-1');
      expect(resultC).toEqual('value-1c');
    });
  });

  describe('should allow to catch an error when failing to open a connection to redis, in order to gracefully handle the error instead of crashing the app', () => {
    test('when connection info are incorrect', async () => {
      expect(redisClientFailure.options.host).toEqual('localhost');
      expect(redisClientFailure.options.port).toEqual(5555);

      try {
        await redisClientFailure.set('key-1', 'value-1'); // This should throw an error, because the connection to redis will be made when executing the
        expect(true).toBe(false); // This shouldn't be called, or the test will fail
      } catch (e) {
        expect(e).toBeDefined();
        expect(e.message).toContain('Reached the max retries per request limit');
      }
      await redisClientFailure.quit();
    });
  });
});

환경 변수:

REDIS_URL=localhost:6379
REDIS_PASSWORD=mypasswordissostrong