Add error handling and statds support

.dockerignore

@@ -55,4 +55,4 @@ local.db
 envfile
 /deploy
 
-.venv/
+.venv/
\ No newline at end of file

.editorconfig

+# EditorConfig is awesome: http://EditorConfig.org
+# top-most EditorConfig file
+root = true
+
+# Unix-style newlines with a newline ending every file
+[*]
+end_of_line = lf
+insert_final_newline = true
+charset = utf-8
+
+# 4 space indentation
+[*.py]
+indent_style = space
+indent_size = 4
+# isort config
+force_single_line=True
+known_third_party=aiocache,aiohttp,funcy,pygtrie,ujson,sanic,statsd,websockets
+
+
+# Tab indentation (no size specified)
+[Makefile]
+indent_style = tab
+
+# Indentation override for all JS under lib directory
+[lib/**.js]
+indent_style = space
+indent_size = 2
+
+# Matches the exact files either package.json or .travis.yml
+[{package.json,.travis.yml}]
+indent_style = space
+indent_size = 2

.pre-commit-config.yaml

+- repo: git://github.com/pre-commit/pre-commit-hooks
+  sha: v0.9.1
+  hooks:
+    - id: check-ast
+    - id: autopep8-wrapper
+    - id: trailing-whitespace
+    - id: check-byte-order-marker
+    - id: check-executables-have-shebangs
+    - id: check-json
+    - id: check-yaml
+    - id: check-symlinks
+    - id: check-case-conflict
+    - id: debug-statements
+    - id: check-merge-conflict
+    - id: detect-aws-credentials
+    - id: detect-private-key
+    - id: end-of-file-fixer
+    - id: fix-encoding-pragma
+    - id: check-added-large-files
+- repo: git://github.com/FalconSocial/pre-commit-python-sorter
+  sha: 1.0.4
+  hooks:
+    - id: python-import-sorter
+      args: ['--silent-overwrite']
+- repo: git://github.com/pre-commit/mirrors-yapf
+  sha: v0.16.2
+  hooks:
+    - id: yapf
+- repo: git://github.com/Lucas-C/pre-commit-hooks
+  sha: v1.0.1
+  hooks:
+    - id: remove-tabs
+      exclude: Makefile
+- repo: local
+  hooks:
+    - id: pylint
+      name: pylint
+      entry: pipenv run pylint
+      language: system
+      types: [python]

pylintrc → .pylintrc

@@ -5,7 +5,7 @@
 
 # Python code to execute, usually for sys.path manipulation such as
 # pygtk.require().
-#init-hook=
+init-hook='import sys; pth="{}/lib/python3.6".format(os.environ.get("VIRTUAL_ENV")); sys.path.append(pth)'
 
 # Add files or directories to the blacklist. They should be base names, not
 # paths.

Dockerfile

 FROM phusion/baseimage:0.9.19
 
-
 ENV LOG_LEVEL INFO
 ENV LANG en_US.UTF-8
 ENV LC_ALL en_US.UTF-8
+ENV PIPENV_VENV_IN_PROJECT 1
 ENV APP_ROOT /app
 ENV APP_CMD ${APP_ROOT}/jussi/serve.py
-ENV PIPENV_VENV_IN_PROJECT 1
-
 # all nginx env vars must also be changed in service/nginx/nginx.conf
 ENV NGINX_SERVER_PORT 8080
-
-
 ENV JUSSI_SERVER_HOST 0.0.0.0
 ENV JUSSI_SERVER_PORT 9000
 ENV JUSSI_STEEMD_WS_URL wss://steemd.steemitdev.com
@@ -19,8 +15,6 @@ ENV JUSSI_SBDS_HTTP_URL https://sbds.steemitdev.com
 ENV JUSSI_REDIS_PORT 6379
 ENV ENVIRONMENT PROD
 
-
-
 RUN \
     apt-get update && \
     apt-get install -y \
@@ -40,18 +34,15 @@ RUN \
         nginx \
         wget
 
-RUN wget -q https://www.scalyr.com/scalyr-repo/stable/latest/scalyr-repo-bootstrap_1.2.1_all.deb
-RUN dpkg -r scalyr-repo scalyr-repo-bootstrap  # Remove any previous repository definitions, if any.
-RUN dpkg -i ./scalyr-repo-bootstrap_1.2.1_all.deb
-
-#RUN rm scalyr-repo-bootstrap_1.2.1_all.deb
-
-RUN \
+# add scalyr agent
+RUN wget -q https://www.scalyr.com/scalyr-repo/stable/latest/scalyr-repo-bootstrap_1.2.1_all.deb && \
+    dpkg -r scalyr-repo scalyr-repo-bootstrap  && \ # Remove any previous repository definitions, if any.
+    dpkg -i ./scalyr-repo-bootstrap_1.2.1_all.deb && \
     apt-get update && \
     apt-get install -y \
         scalyr-repo \
-        scalyr-agent-2
-
+        scalyr-agent-2 && \
+    rm scalyr-repo-bootstrap_1.2.1_all.deb
 
 RUN \
   mkdir -p /var/lib/nginx/body && \
@@ -78,8 +69,8 @@ WORKDIR /app
 RUN \
     pip3 install --upgrade pip && \
     pip3 install pipenv && \
-	pipenv install --three && \
-	pipenv run python3 setup.py install && \
+    pipenv install --three && \
+    pipenv run python3 setup.py install && \
     apt-get remove -y \
         build-essential \
         libffi-dev \
@@ -97,4 +88,3 @@ RUN \
 
 
 EXPOSE ${NGINX_SERVER_PORT}
-

LICENSE

 MIT License
 
-Copyright (c) 2017 
+Copyright (c) 2017
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

Makefile

@@ -24,7 +24,7 @@ run:
 	docker run $(PROJECT_DOCKER_RUN_ARGS) $(PROJECT_DOCKER_TAG)
 
 run-local:
-	pipenv run python3 jussi/serve.py
+	pipenv run python3 jussi/serve.py  --server_workers=1
 
 test:
 	pipenv run py.test tests
@@ -34,4 +34,7 @@ lint:
 
 fmt:
 	pipenv run yapf --recursive --in-place --style pep8 $(PROJECT_NAME)
-	pipenv run autopep8 --recursive --in-placedo $(PROJECT_NAME)
+	pipenv run autopep8 --recursive --in-placedo $(PROJECT_NAME)
\ No newline at end of file
+
+pre-commit:
+	pipenv run pre-commit run --all-files

Pipfile

@@ -14,9 +14,11 @@ sphinxcontrib-programoutput = "*"
 sphinxcontrib-restbuilder = "*"
 yapf = "*"
 autopep8 = "*"
-Sphinx = "*"
+pre_commit = "*"
 certifi = "*"
 urllib3 = "*"
+Sphinx = "*"
+pylint = "*"
 
 [packages]
 ujson = "*"
@@ -27,12 +29,12 @@ cchardet = "*"
 uvloop = "*"
 statsd = "*"
 aiodns = "*"
-Sanic = "*"
 aiocache = "*"
 pygtrie = "*"
 funcy = "*"
 pipenv = "*"
 click = "*"
+Sanic = "*"
 
 [requires]
-python_version = "3.5"
+python_version = "3.6"

README.md

@@ -9,9 +9,9 @@ POST / HTTP/1.1
 Content-Type: application/json
 
 {
-  "method": "sbds.count_operations", 
-  "params": {"operation":"account_creates"}, 
-  "jsonrpc": "2.0", 
+  "method": "sbds.count_operations",
+  "params": {"operation":"account_creates"},
+  "jsonrpc": "2.0",
   "id": 1
 }
 ```
@@ -24,9 +24,9 @@ POST / HTTP/1.1
 Content-Type: application/json
 
 {
-  "method": "get_block", 
-  "params": [1], 
-  "jsonrpc": "2.0", 
+  "method": "get_block",
+  "params": [1],
+  "jsonrpc": "2.0",
   "id": 1
 }
 ```
@@ -37,9 +37,9 @@ POST / HTTP/1.1
 Content-Type: application/json
 
 {
-  "method": "steemd.get_block", 
-  "params": [1], 
-  "jsonrpc": "2.0", 
+  "method": "steemd.get_block",
+  "params": [1],
+  "jsonrpc": "2.0",
   "id": 1
 }
 ```

jussi/__about__.py

+# -*- coding: utf-8 -*-
 __all__ = [
     "__title__",
     "__version__",
-    "__summary",
+    "__summary__",
     "__uri__",
     "__author__",
     "__email__",

jussi/__init__.py

-# -*- coding: utf-8 -*-

jussi/cache.py

-# coding=utf-8
+# -*- coding: utf-8 -*-
 import asyncio
 import hashlib
 import logging
 
+import aiocache
+import aiocache.plugins
 import ujson
 
+from jussi.serializers import CompressionSerializer
+
 logger = logging.getLogger('sanic')
 
 
+
+async def setup_caches(app, loop):
+    logger.info('before_server_start -> setup_cache')
+    args = app.config.args
+    # only use redis if we can really talk to it
+
+    caches_config = {
+        'default': {
+            'cache': aiocache.SimpleMemoryCache,
+            'serializer': {
+                'class': CompressionSerializer
+            },
+            'plugins': [
+                {'class': aiocache.plugins.HitMissRatioPlugin},
+                {'class': aiocache.plugins.TimingPlugin}
+            ]
+        },
+        'redis': {
+            'cache': aiocache.RedisCache,
+            'endpoint': args.redis_host,
+            'port': args.redis_port,
+            'timeout': 3,
+            'serializer': {
+                'class': CompressionSerializer
+            },
+            'plugins': [
+                {'class': aiocache.plugins.HitMissRatioPlugin},
+                {'class': aiocache.plugins.TimingPlugin}
+            ]
+        }
+    }
+    aiocache.caches.set_config(caches_config)
+    try:
+        cache = aiocache.caches.get('redis')
+
+        await cache.set('test', b'testval')
+        val = await cache.get('test')
+        logger.debug('before_server_start -> setup_cache val=%s', val)
+        assert val == b'testval'
+    except Exception as e:
+        logger.exception(e)
+        logger.error(
+            'Unable to use redis (was a setting not defined?), using in-memory cache instead...'
+        )
+        del caches_config['redis']
+        aiocache.caches.set_config(caches_config)
+    return aiocache.caches
+
 def jsonrpc_cache_key(single_jsonrpc_request):
     if isinstance(single_jsonrpc_request.get('params'), dict):
         # the params dict should already be sorted, so no need to sort again
@@ -20,16 +72,19 @@ def jsonrpc_cache_key(single_jsonrpc_request):
                       ).encode()).hexdigest())
 
 
-async def cache_get(app, jussi_attrs):
-    cache = app.config.cache
-    logger.debug('%s.get(%s)', cache, jussi_attrs.key)
-    response = await cache.get(jussi_attrs.key)
-    if response:
-        logger.debug(logger.debug('cache --> %s', response))
-    return response
+async def cache_get(request, jussi_attrs):
+    caches = request.app.config.caches
+    logger.debug('cache.get(%s)', jussi_attrs.key)
+
+    # happy eyeballs approach supports use of multiple caches, eg, SimpleMemoryCache and RedisCache
+    for result in asyncio.as_completed([cache.get(jussi_attrs.key) for cache in caches]):
+        response = await result
+        if response:
+            logger.debug(logger.debug('cache --> %s', response))
+            return response
 
 
-async def cache_set(app, value, jussi_attrs):
+async def cache_set(request, value, jussi_attrs):
     # ttl of -1 means don't cache
     ttl = jussi_attrs.ttl
 
@@ -38,12 +93,16 @@ async def cache_set(app, value, jussi_attrs):
         return
     elif ttl == 0:
         ttl = None
-    cache = app.config.cache
-    logger.debug('%s.set(%s, %s, ttl=%s)', cache, jussi_attrs.key, value, ttl)
-    asyncio.ensure_future(cache.set(jussi_attrs.key, value, ttl=ttl))
+    caches = request.app.config.caches
+    logger.debug('cache.set(%s, %s, ttl=%s)', jussi_attrs.key, value, ttl)
+    for cache in caches:
+        # avoid using too much memory, especially beause there may be os.cpu_count() instances running
+        if isinstance(cache, aiocache.SimpleMemoryCache) and ttl >= 0:
+            ttl = 60
+        asyncio.ensure_future(cache.set(jussi_attrs.key, value, ttl=ttl))
 
 
-async def cache_json_response(app, value, jussi_attrs):
+async def cache_json_response(request, value, jussi_attrs):
     """Don't cache error responses
 
     Args:
@@ -71,4 +130,4 @@ async def cache_json_response(app, value, jussi_attrs):
             parsed['error'], jussi_attrs.upstream_url)
         return
     else:
-        asyncio.ensure_future(cache_set(app, value, jussi_attrs))
+        asyncio.ensure_future(cache_set(request, value, jussi_attrs))

jussi/logging_config.py

-# coding=utf-8
+# -*- coding: utf-8 -*-
 import sys
+
 from sanic.defaultFilter import DefaultFilter
 
 LOGGING = {

jussi/middlewares.py

-# coding=utf-8
-import time
+# -*- coding: utf-8 -*-
 import logging
+import time
 
 from sanic import response
 from sanic.exceptions import InvalidUsage
 
 from .cache import cache_get
+from .timers import init_timers
+from .timers import log_timers
 from .utils import async_exclude_methods
 from .utils import jussi_attrs
-from .utils import replace_jsonrpc_id
 from .utils import sort_request
-from .timers import init_timers
-from .timers import log_timers
 
 logger = logging.getLogger('sanic')
 
@@ -20,7 +19,6 @@ async def start_stats(request):
     request['timers'] = init_timers(start_time=time.time())
     request['statsd'] = request.app.config.statsd_client.pipeline()
 
-
 @async_exclude_methods(exclude_http_methods=('GET', ))
 async def add_jussi_attrs(request):
     # request.json handles json parse errors, this handles empty json
@@ -38,7 +36,7 @@ async def caching_middleware(request):
         return
     jussi_attrs = request['jussi']
     with request['timers']['caching_middleware']:
-        cached_response = await cache_get(request.app, jussi_attrs)
+        cached_response = await cache_get(request, jussi_attrs)
 
     if cached_response:
         return response.raw(
@@ -47,28 +45,27 @@ async def caching_middleware(request):
             headers={'x-jussi-cache-hit': jussi_attrs.key})
 
 
+# pylint: disable=unused-argument
 async def finalize_timers(request, response):
-    end = time.time()
-    if not request.get('timers'):
+    if request.get('timers'):
+        end = time.time()
         logger.info('skipped finalizing timers, no timers to finalize')
         return
-    request['timers']['total_jussi_elapsed']
-    for name, timer in request['timers'].items():
-        timer.end(end)
-    log_timers(request.get('timers'), logger.debug)
+        request['timers']['total_jussi_elapsed'].end()
+        for timer in request['timers'].values():
+            timer.end(end)
+        log_timers(request.get('timers'), logger.debug)
 
 
 async def log_stats(request, response):
-    if not request.get('timers'):
+    if request.get('timers'):
         logger.info('skipped logging timers, no timers to log')
-        return
-    log_timers(request.get('timers'), logger.info)
-
-    try:
-        pipe = request['statsd']
-        logger.info(pipe._stats)
-        for name, timer in request['timers'].items():
-            pipe.timing(name, timer.elapsed)
-        pipe.send()
-    except Exception as e:
-        logger.warning('Failed to send stats to statsd: %s', e)
+        log_timers(request.get('timers'), logger.info)
+        try:
+            pipe = request['statsd']
+            logger.debug(pipe._stats)  # pylint: disable=protected-access
+            for name, timer in request['timers'].items():
+                pipe.timing(name, timer.elapsed)
+            pipe.send()
+        except Exception as e:
+            logger.warning('Failed to send stats to statsd: %s', e)

jussi/serializers.py

-# coding=utf-8
+# -*- coding: utf-8 -*-
 import zlib
-import ujson
 
+import ujson
 from aiocache.serializers import StringSerializer
 
 

jussi/serve.py

-#! /usr/bin/env python3
 # -*- coding: utf-8 -*-
 import argparse
 import asyncio
-import functools
+import datetime
 import logging
 import os
-import ujson
-import datetime
 
-import aiocache
-import aiocache.plugins
 import aiohttp
-import pygtrie
 import funcy
+import pygtrie
+import ujson
 import websockets
-from statsd import StatsClient
 from sanic import Sanic
 from sanic import response
 from sanic.exceptions import SanicException
+from statsd import StatsClient
 
 from jussi.cache import cache_get
 from jussi.cache import cache_json_response
-from jussi.serializers import CompressionSerializer
+from jussi.cache import setup_caches
 from jussi.logging_config import LOGGING
 from jussi.middlewares import add_jussi_attrs
 from jussi.middlewares import caching_middleware
-from jussi.middlewares import start_stats
 from jussi.middlewares import finalize_timers
 from jussi.middlewares import log_stats
-from jussi.utils import websocket_conn
+from jussi.middlewares import start_stats
 from jussi.utils import return_bytes
+from jussi.utils import websocket_conn
 
 # init logging
 LOG_LEVEL = getattr(logging, os.environ.get('LOG_LEVEL', 'INFO'))
@@ -52,6 +48,8 @@ METHOD_CACHE_SETTINGS = (('get_block', 'steemd_websocket_url',
                          ('get_global_dynamic_properties',
                           'steemd_websocket_url', 1))
 
+# pylint: disable=unused-argument
+
 
 @funcy.log_calls(logger.debug)
 @return_bytes
@@ -88,7 +86,7 @@ async def dispatch_single(sanic_http_request, jsonrpc_request, jrpc_req_index):
 
     # return cached response if possible
     with sanic_http_request['timers'][prefix('dispatch_single_caching_check')]:
-        response = await cache_get(app, jussi_attrs)
+        response = await cache_get(sanic_http_request, jussi_attrs)
     if response:
         return response
 
@@ -101,7 +99,7 @@ async def dispatch_single(sanic_http_request, jsonrpc_request, jrpc_req_index):
                                               jsonrpc_request)
 
     asyncio.ensure_future(
-        cache_json_response(app, bytes_response, jussi_attrs=jussi_attrs))
+        cache_json_response(sanic_http_request, bytes_response, jussi_attrs=jussi_attrs))
     return bytes_response
 
 
@@ -122,7 +120,7 @@ async def dispatch_batch(sanic_http_request, jsonrpc_requests):
 
 
 @app.post('/')
-async def handle(sanic_http_request):
+async def handle_jsonrpc(sanic_http_request):
     app = sanic_http_request.app
 
     # retreive parsed jsonrpc_requests after request middleware processing
@@ -147,7 +145,7 @@ async def handle(sanic_http_request):
 
 # health check routes
 @app.get('/')
-async def handle(sanic_http_request):
+async def handle_root_health(sanic_http_request):
     return response.json({
         'status': 'OK',
         'datetime': datetime.datetime.utcnow().isoformat()
@@ -155,7 +153,7 @@ async def handle(sanic_http_request):
 
 
 @app.get('/health')
-async def handle(sanic_http_request):
+async def handle_health(sanic_http_request):
     return response.json({
         'status': 'OK',
         'datetime': datetime.datetime.utcnow().isoformat()
@@ -164,7 +162,7 @@ async def handle(sanic_http_request):
 
 @app.exception(SanicException)
 def handle_errors(request, exception):
-    """all errors return HTTP 502
+    """handles all errors
 
     Args:
         request:
@@ -173,14 +171,14 @@ def handle_errors(request, exception):
     Returns:
 
     """
+    logger.exception('%s caused %s', request, exception)
     status_code = getattr(exception, 'status_code', 502)
     message = str(exception) or 'Gateway Error'
-    logger.error('%s-%s', request, exception)
-    return response.json(
+    return response.json(status=status_code, body=
         {
-            'error': message,
+            'error': 'Gateway Error',
             'status_code': status_code
-        }, status=status_code)
+        })
 
 
 # register listeners
@@ -210,53 +208,27 @@ def setup_middlewares(app, loop):
     app.request_middleware.append(add_jussi_attrs)
     app.request_middleware.append(caching_middleware)
 
-    app.response_middleware.append(finalize_timers)
-    app.response_middleware.append(log_stats)
+    #app.response_middleware.append(finalize_timers)
+    #app.response_middleware.append(log_stats)
 
 
 @app.listener('before_server_start')
 async def setup_cache(app, loop):
     logger.info('before_server_start -> setup_cache')
     args = app.config.args
-    # only use redis if we can really talk to it
-    logger.info('before_server_start -> setup_cache redis_host:%s',
-                args.redis_host)
-    logger.info('before_server_start -> setup_cache redis_port:%s',
-                args.redis_port)
-    try:
-        if not args.redis_host:
-            raise ValueError('no redis host specified')
-        default_cache = aiocache.RedisCache(
-            serializer=CompressionSerializer(),
-            endpoint=args.redis_host,
-            port=args.redis_port,
-            plugins=[
-                aiocache.plugins.HitMissRatioPlugin(),
-                aiocache.plugins.TimingPlugin()
-            ])
-        await default_cache.set('test', b'testval')
-        val = await default_cache.get('test')
-        logger.debug('before_server_start -> setup_cache val=%s', val)
-        assert val == b'testval'
-    except Exception as e:
-        logger.exception(e)
-        logger.error(
-            'Unable to use redis (was a setting not defined?), using in-memory cache instead...'
-        )
-        default_cache = aiocache.SimpleMemoryCache(
-            serializer=CompressionSerializer(),
-            plugins=[
-                aiocache.plugins.HitMissRatioPlugin(),
-                aiocache.plugins.TimingPlugin()
-            ])
-    logger.info('before_server_start -> setup_cache cache=%s', default_cache)
+    caches = await setup_caches(app, loop)
+    for cache_alias in caches.get_config().keys():
+        logger.info('before_server_start -> setup_cache caches=%s', cache_alias)
+    active_caches = [caches.get(alias) for alias in caches.get_config().keys()]
+
     cache_config = dict()
     cache_config['default_cache_ttl'] = DEFAULT_CACHE_TTL
     cache_config['no_cache_ttl'] = NO_CACHE_TTL
     cache_config['no_cache_expire_ttl'] = NO_CACHE_EXPIRE_TTL
 
+
     app.config.cache_config = cache_config
-    app.config.cache = default_cache
+    app.config.caches = active_caches
 
 
 @app.listener('before_server_start')

jussi/timers.py

-# coding=utf-8
+# -*- coding: utf-8 -*-
 import time
 from collections import defaultdict
 
@@ -6,13 +6,13 @@ from collections import defaultdict
 class Timer(object):
     __slots__ = ('_start_time', '_end_time')
 
-    def __init__(self, start=None, end=None):
-        self._start_time = start or time.time()
+    def __init__(self, start_time=None, end=None):
+        self._start_time = start_time or time.time()
         self._end_time = end
 
-    def start(self, start=None):
-        if start:
-            self._start_time = start
+    def start(self, start_time=None):
+        if start_time:
+            self._start_time = start_time
 
     def restart(self):
         self._start_time = time.time()
@@ -34,7 +34,7 @@ class Timer(object):
         return str(self.elapsed)
 
     def __repr__(self):
-        return self.elapsed
+        return 'Timer(start_time=%s end_time=%s elapsed=%s)' % (self._start_time, self._end_time, self.elapsed)
 
     def __enter__(self, start=None):
         if start:
@@ -46,11 +46,11 @@ class Timer(object):
 
 
 def init_timers(start_time=None):
-    return defaultdict(lambda: Timer(start=start_time))
+    return defaultdict(lambda: Timer(start_time=start_time))
 
 
 def end_timers(timers, end=None):
-    for name, timer in timers.items():
+    for timer in timers.values():
         if end:
             timer.end(end)
     return timers
@@ -63,6 +63,6 @@ def display_timers(timers, end=None):
         print('%s %s' % (name, timer))
 
 
-def log_timers(timers, log_func, end=None):
+def log_timers(timers, log_func):
     for name, timer in timers.items():
         log_func('%s %s' % (name, timer))

jussi/utils.py

 # -*- coding: utf-8 -*-
 import functools
-import time
 import logging
-import websockets
-
+import time
 from collections import OrderedDict
 from collections import namedtuple
+
+import websockets
 from sanic.exceptions import InvalidUsage
 
 from jussi.cache import jsonrpc_cache_key
@@ -87,9 +87,8 @@ def async_exclude_methods(middleware_func=None, exclude_http_methods=None):
     @functools.wraps(middleware_func)
     async def f(request):
         if request.method in exclude_http_methods:
-            return request
-        else:
-            return await middleware_func(request)
+            return
+        return await middleware_func(request)
 
     return f
 

service/jussi/run

@@ -15,4 +15,4 @@ exec 2>&1 \
       --sbds_url "${JUSSI_SBDS_HTTP_URL}" \
       --redis_host "${JUSSI_REDIS_HOST:-''}" \
       --redis_port "${JUSSI_REDIS_PORT:-6379}" \
-      2>&1
+      2>&1
\ No newline at end of file

service/nginx/nginx.conf

@@ -68,4 +68,4 @@ upstream jussi_upstream {
       proxy_pass http://jussi_upstream;
     }
   }
-}
+}
\ No newline at end of file