Sign upLogin

rollbar/pyrollbar

View on GitHub
Star
rollbar/__init__.py

Summary

Maintainability
F
1 wk
Test Coverage

File __init__.py has 1344 lines of code (exceeds 250 allowed). Consider refactoring.
Open

from __future__ import absolute_import
from __future__ import unicode_literals

import copy
import functools
Severity: Major
Found in rollbar/__init__.py - About 3 days to fix

    Function _add_locals_data has a Cognitive Complexity of 34 (exceeds 5 allowed). Consider refactoring.
    Open

    def _add_locals_data(trace_data, exc_info):
    if not SETTINGS['locals']['enabled']:
        return

    frames = trace_data['frames']
    Severity: Minor
    Found in rollbar/__init__.py - About 5 hrs to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    Function _build_person_data has a Cognitive Complexity of 27 (exceeds 5 allowed). Consider refactoring.
    Open

    def _build_person_data(request):
    """
    Returns a dictionary describing the logged-in user using data from `request`.

    Try request.rollbar_person first, then 'user', then 'user_id'
    Severity: Minor
    Found in rollbar/__init__.py - About 3 hrs to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    Function send_payload has a Cognitive Complexity of 24 (exceeds 5 allowed). Consider refactoring.
    Open

    def send_payload(payload, access_token):
    """
    Sends a payload object, (the result of calling _build_payload() + _serialize_payload()).
    Uses the configured handler from SETTINGS['handler']
    Severity: Minor
    Found in rollbar/__init__.py - About 3 hrs to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    Function _parse_response has a Cognitive Complexity of 20 (exceeds 5 allowed). Consider refactoring.
    Open

    def _parse_response(path, access_token, params, resp, endpoint=None):
    if isinstance(resp, requests.Response):
        try:
            data = resp.text
        except Exception:
    Severity: Minor
    Found in rollbar/__init__.py - About 2 hrs to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    Function _report_exc_info has a Cognitive Complexity of 17 (exceeds 5 allowed). Consider refactoring.
    Open

    def _report_exc_info(exc_info, request, extra_data, payload_data, level=None):
    """
    Called by report_exc_info() wrapper
    """
    Severity: Minor
    Found in rollbar/__init__.py - About 2 hrs to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    Function _filter_ip has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.
    Open

    def _filter_ip(request_data, capture_ip):
    if 'user_ip' not in request_data or capture_ip == True:
        return

    current_ip = request_data['user_ip']
    Severity: Minor
    Found in rollbar/__init__.py - About 1 hr to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    Function init has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.
    Open

    def init(access_token, environment='production', scrub_fields=None, url_fields=None, **kw):
    """
    Saves configuration variables in this module's SETTINGS.

    access_token: project access token. Get this from the Rollbar UI:
    Severity: Minor
    Found in rollbar/__init__.py - About 1 hr to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    Function _build_request_data has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.
    Open

    def _build_request_data(request):
    """
    Returns a dictionary containing data from the request.
    """
    Severity: Minor
    Found in rollbar/__init__.py - About 1 hr to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    Function _build_starlette_request_data has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.
    Open

    def _build_starlette_request_data(request):
    from starlette.datastructures import UploadFile

    request_data = {
        'url': str(request.url),
    Severity: Minor
    Found in rollbar/__init__.py - About 1 hr to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    Function report_exc_info has 6 arguments (exceeds 4 allowed). Consider refactoring.
    Open

    def report_exc_info(exc_info=None, request=None, extra_data=None, payload_data=None, level=None, **kw):
    Severity: Minor
    Found in rollbar/__init__.py - About 45 mins to fix

      Avoid deeply nested control flow statements.
      Open

                              for i, arg in enumerate(temp_varargs):
                            temp_varargs[i] = REDACT_REF
      Severity: Major
      Found in rollbar/__init__.py - About 45 mins to fix

        Function _add_person_data has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
        Open

        def _add_person_data(data, request):
    try:
        person_data = _build_person_data(request)
    except Exception as e:
        log.exception("Exception while building person data for Rollbar payload: %r", e)
        Severity: Minor
        Found in rollbar/__init__.py - About 45 mins to fix

        Cognitive Complexity

        Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

        A method's cognitive complexity is based on a few simple rules:

        • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
        • Code is considered more complex for each "break in the linear flow of the code"
        • Code is considered more complex when "flow breaking structures are nested"

        Further reading

        Function __init__ has 6 arguments (exceeds 4 allowed). Consider refactoring.
        Open

            def __init__(self, access_token, path, page_num, params, data, endpoint=None):
        Severity: Minor
        Found in rollbar/__init__.py - About 45 mins to fix

          Function search_items has 5 arguments (exceeds 4 allowed). Consider refactoring.
          Open

          def search_items(title, return_fields=None, access_token=None, endpoint=None, **search_fields):
          Severity: Minor
          Found in rollbar/__init__.py - About 35 mins to fix

            Function init has 5 arguments (exceeds 4 allowed). Consider refactoring.
            Open

            def init(access_token, environment='production', scrub_fields=None, url_fields=None, **kw):
            Severity: Minor
            Found in rollbar/__init__.py - About 35 mins to fix

              Function _report_exc_info has 5 arguments (exceeds 4 allowed). Consider refactoring.
              Open

              def _report_exc_info(exc_info, request, extra_data, payload_data, level=None):
              Severity: Minor
              Found in rollbar/__init__.py - About 35 mins to fix

                Function _report_message has 5 arguments (exceeds 4 allowed). Consider refactoring.
                Open

                def _report_message(message, level, request, extra_data, payload_data):
                Severity: Minor
                Found in rollbar/__init__.py - About 35 mins to fix

                  Function _parse_response has 5 arguments (exceeds 4 allowed). Consider refactoring.
                  Open

                  def _parse_response(path, access_token, params, resp, endpoint=None):
                  Severity: Minor
                  Found in rollbar/__init__.py - About 35 mins to fix

                    Function report_message has 5 arguments (exceeds 4 allowed). Consider refactoring.
                    Open

                    def report_message(message, level='error', request=None, extra_data=None, payload_data=None):
                    Severity: Minor
                    Found in rollbar/__init__.py - About 35 mins to fix

                      Avoid too many return statements within this function.
                      Open

                              return _build_fastapi_request_data(request)
                      Severity: Major
                      Found in rollbar/__init__.py - About 30 mins to fix

                        Avoid too many return statements within this function.
                        Open

                                return _build_bottle_request_data(request)
                        Severity: Major
                        Found in rollbar/__init__.py - About 30 mins to fix

                          Avoid too many return statements within this function.
                          Open

                                      return retval
                          Severity: Major
                          Found in rollbar/__init__.py - About 30 mins to fix

                            Avoid too many return statements within this function.
                            Open

                                    return _build_wsgi_request_data(request)
                            Severity: Major
                            Found in rollbar/__init__.py - About 30 mins to fix

                              Avoid too many return statements within this function.
                              Open

                                          return
                              Severity: Major
                              Found in rollbar/__init__.py - About 30 mins to fix

                                Avoid too many return statements within this function.
                                Open

                                        return _build_tornado_request_data(request)
                                Severity: Major
                                Found in rollbar/__init__.py - About 30 mins to fix

                                  Avoid too many return statements within this function.
                                  Open

                                          return _build_starlette_request_data(request)
                                  Severity: Major
                                  Found in rollbar/__init__.py - About 30 mins to fix

                                    Avoid too many return statements within this function.
                                    Open

                                            return {'id': str(user_id)}
                                    Severity: Major
                                    Found in rollbar/__init__.py - About 30 mins to fix

                                      Avoid too many return statements within this function.
                                      Open

                                              return _build_sanic_request_data(request)
                                      Severity: Major
                                      Found in rollbar/__init__.py - About 30 mins to fix

                                        Avoid too many return statements within this function.
                                        Open

                                            return None
                                        Severity: Major
                                        Found in rollbar/__init__.py - About 30 mins to fix

                                          Avoid too many return statements within this function.
                                          Open

                                                      return
                                          Severity: Major
                                          Found in rollbar/__init__.py - About 30 mins to fix

                                            Avoid too many return statements within this function.
                                            Open

                                                        return None
                                            Severity: Major
                                            Found in rollbar/__init__.py - About 30 mins to fix

                                              Avoid too many return statements within this function.
                                              Open

                                                      return _build_falcon_request_data(request)
                                              Severity: Major
                                              Found in rollbar/__init__.py - About 30 mins to fix

                                                Function _build_wsgi_request_data has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
                                                Open

                                                def _build_wsgi_request_data(request):
    request_data = {
        'url': wsgiref.util.request_uri(request),
        'user_ip': _wsgi_extract_user_ip(request),
        'method': request.get('REQUEST_METHOD'),
                                                Severity: Minor
                                                Found in rollbar/__init__.py - About 25 mins to fix

                                                Cognitive Complexity

                                                Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                                                A method's cognitive complexity is based on a few simple rules:

                                                • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                                                • Code is considered more complex for each "break in the linear flow of the code"
                                                • Code is considered more complex when "flow breaking structures are nested"

                                                Further reading

                                                Function _walk_trace_chain has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
                                                Open

                                                def _walk_trace_chain(cls, exc, trace):
    trace_chain = [_trace_data(cls, exc, trace)]

    seen_exceptions = {exc}
                                                Severity: Minor
                                                Found in rollbar/__init__.py - About 25 mins to fix

                                                Cognitive Complexity

                                                Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                                                A method's cognitive complexity is based on a few simple rules:

                                                • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                                                • Code is considered more complex for each "break in the linear flow of the code"
                                                • Code is considered more complex when "flow breaking structures are nested"

                                                Further reading

                                                Similar blocks of code found in 4 locations. Consider refactoring.
                                                Open

                                                def _send_payload_tornado(payload_str, access_token):
    try:
        _post_api_tornado('item/', payload_str, access_token=access_token)
    except Exception as e:
        log.exception('Exception while posting item %r', e)
                                                Severity: Major
                                                Found in rollbar/__init__.py and 3 other locations - About 1 hr to fix
                                                rollbar/__init__.py on lines 1508..1512
                                                rollbar/__init__.py on lines 1520..1524
                                                rollbar/__init__.py on lines 1613..1617

                                                Duplicated Code

                                                Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                Tuning

                                                This issue has a mass of 38.

                                                We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                Refactorings

                                                Further Reading

                                                Similar blocks of code found in 4 locations. Consider refactoring.
                                                Open

                                                def _send_payload_appengine(payload_str, access_token):
    try:
        _post_api_appengine('item/', payload_str, access_token=access_token)
    except Exception as e:
        log.exception('Exception while posting item %r', e)
                                                Severity: Major
                                                Found in rollbar/__init__.py and 3 other locations - About 1 hr to fix
                                                rollbar/__init__.py on lines 1508..1512
                                                rollbar/__init__.py on lines 1577..1581
                                                rollbar/__init__.py on lines 1613..1617

                                                Duplicated Code

                                                Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                Tuning

                                                This issue has a mass of 38.

                                                We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                Refactorings

                                                Further Reading

                                                Similar blocks of code found in 4 locations. Consider refactoring.
                                                Open

                                                def _send_payload_pool(payload_str, access_token):
    try:
        _post_api('item/', payload_str, access_token=access_token)
    except Exception as e:
        log.exception('Exception while posting item %r', e)
                                                Severity: Major
                                                Found in rollbar/__init__.py and 3 other locations - About 1 hr to fix
                                                rollbar/__init__.py on lines 1520..1524
                                                rollbar/__init__.py on lines 1577..1581
                                                rollbar/__init__.py on lines 1613..1617

                                                Duplicated Code

                                                Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                Tuning

                                                This issue has a mass of 38.

                                                We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                Refactorings

                                                Further Reading

                                                Similar blocks of code found in 4 locations. Consider refactoring.
                                                Open

                                                def _send_payload_twisted(payload_str, access_token):
    try:
        _post_api_twisted('item/', payload_str, access_token=access_token)
    except Exception as e:
        log.exception('Exception while posting item %r', e)
                                                Severity: Major
                                                Found in rollbar/__init__.py and 3 other locations - About 1 hr to fix
                                                rollbar/__init__.py on lines 1508..1512
                                                rollbar/__init__.py on lines 1520..1524
                                                rollbar/__init__.py on lines 1577..1581

                                                Duplicated Code

                                                Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                Tuning

                                                This issue has a mass of 38.

                                                We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                Refactorings

                                                Further Reading

                                                Similar blocks of code found in 2 locations. Consider refactoring.
                                                Open

                                                            if not SETTINGS['capture_username'] and 'username' in person_data:
                person_data['username'] = None
                                                Severity: Minor
                                                Found in rollbar/__init__.py and 1 other location - About 50 mins to fix
                                                rollbar/__init__.py on lines 926..927

                                                Duplicated Code

                                                Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                Tuning

                                                This issue has a mass of 36.

                                                We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                Refactorings

                                                Further Reading

                                                Similar blocks of code found in 2 locations. Consider refactoring.
                                                Open

                                                            if not SETTINGS['capture_email'] and 'email' in person_data:
                person_data['email'] = None
                                                Severity: Minor
                                                Found in rollbar/__init__.py and 1 other location - About 50 mins to fix
                                                rollbar/__init__.py on lines 924..925

                                                Duplicated Code

                                                Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                Tuning

                                                This issue has a mass of 36.

                                                We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                Refactorings

                                                Further Reading

                                                There are no issues that match your filters.

                                                Category
                                                Status