Sign upLogin

palourde/uchiwa

View on GitHub
Star

Showing 81 of 81 total issues

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

func (d *DatacenterSnapshotFetcher) fetchClients(ctx context.Context, errCh chan error) {
    defer d.wg.Done()

    for {
        select {
Severity: Major
Found in uchiwa/daemon/daemon.go and 3 other locations - About 2 hrs to fix
uchiwa/daemon/daemon.go on lines 271..294
uchiwa/daemon/daemon.go on lines 296..322
uchiwa/daemon/daemon.go on lines 352..376

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 207.

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

Function initUchiwa has a Cognitive Complexity of 32 (exceeds 20 allowed). Consider refactoring.
Open

func initUchiwa(global GlobalConfig) GlobalConfig {

    // Set the proper authentication driver
    if global.Github.Server != "" {
        global.Auth.Driver = "github"
Severity: Minor
Found in uchiwa/config/config.go - 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

Method DatacenterFetcher.Fetch has 77 lines of code (exceeds 50 allowed). Consider refactoring.
Open

func (f *DatacenterFetcher) Fetch() {
    defer f.wg.Done()

    logger.Infof("updating the datacenter %s", f.datacenter.Name)
Severity: Major
Found in uchiwa/daemon/daemon.go - About 2 hrs to fix

    Function IsCheckSilenced has 77 lines of code (exceeds 50 allowed). Consider refactoring.
    Open

    func IsCheckSilenced(check, client map[string]interface{}, dc string, silenced []interface{}) (bool, []string) {
    var isSilenced bool
    var commonSubscriptions, isSilencedBy, subscribers, subscriptions []string

    if dc == "" || len(silenced) == 0 {
    Severity: Major
    Found in uchiwa/helpers/helpers.go - About 2 hrs to fix

      Function exports has 50 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

      module.exports = function (grunt) {
  grunt.loadNpmTasks("grunt-cache-breaker");

  grunt.initConfig({
    cachebreaker: {
      Severity: Minor
      Found in Gruntfile.js - About 2 hrs to fix

        Method Uchiwa.aggregateHandler has 22 return statements (exceeds 4 allowed).
        Open

        func (u *Uchiwa) aggregateHandler(w http.ResponseWriter, r *http.Request) {
    if r.Method != http.MethodGet && r.Method != http.MethodHead && r.Method != http.MethodDelete {
        http.Error(w, "", http.StatusBadRequest)
        return
    }
        Severity: Major
        Found in uchiwa/server.go - About 2 hrs to fix

          Method API.doRequest has 71 lines of code (exceeds 50 allowed). Consider refactoring.
          Open

          func (api *API) doRequest(req *http.Request) ([]byte, *http.Response, error) {
    if api.User != "" && api.Pass != "" {
        req.SetBasicAuth(api.User, api.Pass)
    }
          Severity: Minor
          Found in uchiwa/sensu/request.go - About 1 hr to fix

            Method Uchiwa.checkHandler has 70 lines of code (exceeds 50 allowed). Consider refactoring.
            Open

            func (u *Uchiwa) checkHandler(w http.ResponseWriter, r *http.Request) {
    // We only support DELETE & GET requests
    if r.Method != http.MethodGet && r.Method != http.MethodHead {
        http.Error(w, "", http.StatusBadRequest)
        return
            Severity: Minor
            Found in uchiwa/server.go - About 1 hr to fix

              Function GetEvent has a Cognitive Complexity of 29 (exceeds 20 allowed). Consider refactoring.
              Open

              func GetEvent(check, client, dc string, events *[]interface{}) (map[string]interface{}, error) {
    if check == "" || client == "" || dc == "" || len(*events) == 0 {
        return nil, errors.New("No parameters should be empty")
    }
              Severity: Minor
              Found in uchiwa/helpers/helpers.go - 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

              Method Uchiwa.silencedHandler has 68 lines of code (exceeds 50 allowed). Consider refactoring.
              Open

              func (u *Uchiwa) silencedHandler(w http.ResponseWriter, r *http.Request) {
    token := authentication.GetJWTFromContext(r)

    if r.Method == http.MethodGet || r.Method == http.MethodHead {
        // GET on /silenced
              Severity: Minor
              Found in uchiwa/server.go - About 1 hr to fix

                Method Uchiwa.resultsHandler has 67 lines of code (exceeds 50 allowed). Consider refactoring.
                Open

                func (u *Uchiwa) resultsHandler(w http.ResponseWriter, r *http.Request) {
    if r.Method != http.MethodDelete {
        http.Error(w, "", http.StatusBadRequest)
        return
    }
                Severity: Minor
                Found in uchiwa/server.go - About 1 hr to fix

                  Method Uchiwa.stashHandler has 67 lines of code (exceeds 50 allowed). Consider refactoring.
                  Open

                  func (u *Uchiwa) stashHandler(w http.ResponseWriter, r *http.Request) {
    if r.Method != http.MethodDelete {
        http.Error(w, "", http.StatusBadRequest)
        return
    }
                  Severity: Minor
                  Found in uchiwa/server.go - About 1 hr to fix

                    Method Uchiwa.eventHandler has 67 lines of code (exceeds 50 allowed). Consider refactoring.
                    Open

                    func (u *Uchiwa) eventHandler(w http.ResponseWriter, r *http.Request) {
    if r.Method != http.MethodDelete {
        http.Error(w, "", http.StatusBadRequest)
        return
    }
                    Severity: Minor
                    Found in uchiwa/server.go - About 1 hr to fix

                      Function rawMetricsToAggregatedCoordinates has 67 lines of code (exceeds 50 allowed). Consider refactoring.
                      Open

                      func rawMetricsToAggregatedCoordinates(rawMetrics []*structs.SERawMetric) *structs.SEMetric {
    // Find the oldest data point in the last position
    var oldest float64
    for _, metrics := range rawMetrics {
        count := len(metrics.Points)
                      Severity: Minor
                      Found in uchiwa/daemon/metrics.go - About 1 hr to fix

                        Method Uchiwa.clientHandler has 18 return statements (exceeds 4 allowed).
                        Open

                        func (u *Uchiwa) clientHandler(w http.ResponseWriter, r *http.Request) {
    // We only support DELETE & GET requests
    if r.Method != http.MethodDelete && r.Method != http.MethodGet && r.Method != http.MethodHead {
        http.Error(w, "", http.StatusBadRequest)
        return
                        Severity: Major
                        Found in uchiwa/server.go - About 1 hr to fix

                          Method API.doRequest has a Cognitive Complexity of 28 (exceeds 20 allowed). Consider refactoring.
                          Open

                          func (api *API) doRequest(req *http.Request) ([]byte, *http.Response, error) {
    if api.User != "" && api.Pass != "" {
        req.SetBasicAuth(api.User, api.Pass)
    }
                          Severity: Minor
                          Found in uchiwa/sensu/request.go - 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 initUchiwa has 64 lines of code (exceeds 50 allowed). Consider refactoring.
                          Open

                          func initUchiwa(global GlobalConfig) GlobalConfig {

    // Set the proper authentication driver
    if global.Github.Server != "" {
        global.Auth.Driver = "github"
                          Severity: Minor
                          Found in uchiwa/config/config.go - About 1 hr to fix

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

                            func (u *Uchiwa) findStash(path string) ([]interface{}, error) {
    var stashes []interface{}
    for _, c := range u.Data.Stashes {
        m, ok := c.(map[string]interface{})
        if !ok {
                            Severity: Major
                            Found in uchiwa/stash.go and 3 other locations - About 1 hr to fix
                            uchiwa/aggregate.go on lines 94..112
                            uchiwa/check.go on lines 51..69
                            uchiwa/client.go on lines 50..68

                            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 162.

                            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

                            func (u *Uchiwa) findClient(name string) ([]interface{}, error) {
    var clients []interface{}
    for _, c := range u.Data.Clients {
        m, ok := c.(map[string]interface{})
        if !ok {
                            Severity: Major
                            Found in uchiwa/client.go and 3 other locations - About 1 hr to fix
                            uchiwa/aggregate.go on lines 94..112
                            uchiwa/check.go on lines 51..69
                            uchiwa/stash.go on lines 48..66

                            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 162.

                            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

                            func (u *Uchiwa) findCheck(name string) ([]interface{}, error) {
    var checks []interface{}
    for _, c := range u.Data.Checks {
        m, ok := c.(map[string]interface{})
        if !ok {
                            Severity: Major
                            Found in uchiwa/check.go and 3 other locations - About 1 hr to fix
                            uchiwa/aggregate.go on lines 94..112
                            uchiwa/client.go on lines 50..68
                            uchiwa/stash.go on lines 48..66

                            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 162.

                            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

                            Severity
                            Category
                            Status
                            Source
                            Language