コード例 #1
0
    def test_stacktrace(self):
        l = {
            "level": "info",
            "ts": 1589379832.5167677,
            "logger": "cmd",
            "msg": ""
        }
        r1 = bmlp.Record(l)
        self.assertIsNone(r1.context)

        e = {
            "level":
            "error",
            "ts":
            1589381055.1638162,
            "logger":
            "controller-runtime.controller",
            "msg":
            "Reconciler error",
            "controller":
            "metal3-baremetalhost-controller",
            "request":
            "metal3/somehost",
            "error":
            "failed to save host status after \"ready\".",
            "stacktrace":
            "github.com/go-logr/zapr.(*zapLogger).Error\n"
            "\t/go/pkg/mod/github.com/go-logr/[email protected]/zapr.go:128"
        }
        r2 = bmlp.Record(e)
        self.assertEqual(
            'github.com/go-logr/zapr.(*zapLogger).Error\n'
            '\t/go/pkg/mod/github.com/go-logr/[email protected]/'
            'zapr.go:128', r2.context)
コード例 #2
0
    def test_error_data(self):
        e = {
            "level":
            "error",
            "ts":
            1589381055.1638162,
            "logger":
            "controller-runtime.controller",
            "msg":
            "Reconciler error",
            "controller":
            "metal3-baremetalhost-controller",
            "request":
            "metal3/somehost",
            "error":
            "failed to save host status after \"ready\".",
            "errorVerbose":
            "The error message and the stack trace "
            "concatenated for no good reason",
            "stacktrace":
            "github.com/go-logr/zapr.(*zapLogger).Error\n"
            "\t/go/pkg/mod/github.com/go-logr/[email protected]/zapr.go:128"
        }
        r = bmlp.Record(e)

        self.assertSetEqual({'controller', 'request'}, set(r.data.keys()))
コード例 #3
0
 def test_name_controller_runtime(self):
     e = {
         "level":
         "error",
         "ts":
         1589381055.1638162,
         "logger":
         "controller-runtime.manager.controller.baremetalhost",
         "msg":
         "Reconciler error",
         "reconciler group":
         "metal3.io",
         "reconciler kind":
         "BareMetalHost",
         "namespace":
         "metal3",
         "name":
         "somehost",
         "error":
         "failed to save host status after \"ready\".",
         "stacktrace":
         "github.com/go-logr/zapr.(*zapLogger).Error\n"
         "\t/go/pkg/mod/github.com/go-logr/[email protected]/zapr.go:128"
     }
     err = bmlp.Record(e)
     self.assertEqual('somehost', err.name)
コード例 #4
0
    def test_format_stacktrace(self):
        e = {
            "level":
            "error",
            "ts":
            1589381055.1638162,
            "logger":
            "controller-runtime.controller",
            "msg":
            "Reconciler error",
            "controller":
            "metal3-baremetalhost-controller",
            "request":
            "metal3/somehost",
            "error":
            "failed to save host status after \"ready\".",
            "errorVerbose":
            "The error message and the stack trace "
            "concatenated for no good reason",
            "stacktrace":
            "github.com/go-logr/zapr.(*zapLogger).Error\n"
            "\t/go/pkg/mod/github.com/go-logr/[email protected]/zapr.go:128"
        }
        r = bmlp.Record(e)

        self.assertEqual(
            '2020-05-13T14:44:15.163 Reconciler error {'
            "controller: 'metal3-baremetalhost-controller', "
            "request: 'metal3/somehost'}\n"
            'failed to save host status after "ready".\n'
            'github.com/go-logr/zapr.(*zapLogger).Error\n'
            '\t/go/pkg/mod/github.com/go-logr/[email protected]/zapr.go:128',
            r.format())
コード例 #5
0
    def test_format_error_stacktrace_highlight(self):
        l = {
            "level":
            "error",
            "ts":
            1589381055.1638162,
            "logger":
            "controller-runtime.controller",
            "msg":
            "Reconciler error",
            "controller":
            "metal3-baremetalhost-controller",
            "request":
            "metal3/somehost",
            "error":
            "failed to save host status after \"ready\".",
            "stacktrace":
            "github.com/go-logr/zapr.(*zapLogger).Error\n"
            "\t/go/pkg/mod/github.com/go-logr/[email protected]/zapr.go:128"
        }
        r = bmlp.Record(l)

        self.assertEqual(
            '\033[91m2020-05-13T14:44:15.163 '
            '\033[31mReconciler error\033[91m {'
            "controller: 'metal3-baremetalhost-controller', "
            "request: 'metal3/somehost'}\033[39m\n"
            '\033[31mfailed to save host status after "ready".\033[39m\n'
            '\033[90mgithub.com/go-logr/zapr.(*zapLogger).Error\033[39m\n'
            '\033[90m\t/go/pkg/mod/github.com/go-logr/[email protected]/'
            'zapr.go:128\033[39m', r.format(highlight=True))
コード例 #6
0
    def test_namespace_controller_runtime(self):
        ip_ns = {
            "level": "info",
            "ts": 1589380774.1379526,
            "logger": "provisioner.ironic",
            "msg": "validating management access",
            "host": "metal3~somehost"
        }
        ironic_prov_ns = bmlp.Record(ip_ns)
        self.assertEqual('metal3', ironic_prov_ns.namespace)

        b = {
            "level": "info",
            "ts": 1589380774.1207273,
            "logger": "controllers.BareMetalHost",
            "msg": "start",
            "baremetalhost": "metal3/somehost"
        }
        bmh = bmlp.Record(b)
        self.assertEqual('metal3', bmh.namespace)

        e = {
            "level":
            "error",
            "ts":
            1589381055.1638162,
            "logger":
            "controller-runtime.manager.controller.baremetalhost",
            "msg":
            "Reconciler error",
            "reconciler group":
            "metal3.io",
            "reconciler kind":
            "BareMetalHost",
            "namespace":
            "metal3",
            "name":
            "somehost",
            "error":
            "failed to save host status after \"ready\".",
            "stacktrace":
            "github.com/go-logr/zapr.(*zapLogger).Error\n"
            "\t/go/pkg/mod/github.com/go-logr/[email protected]/zapr.go:128"
        }
        err = bmlp.Record(e)
        self.assertEqual('metal3', err.namespace)
コード例 #7
0
    def test_level(self):
        l = {
            "level": "info",
            "ts": 1589379832.5167677,
            "logger": "cmd",
            "msg": ""
        }
        r1 = bmlp.Record(l)
        self.assertEqual(bmlp.INFO, r1.level)

        l = {
            "level": "error",
            "ts": 1589379832.5167677,
            "logger": "cmd",
            "msg": ""
        }
        r2 = bmlp.Record(l)
        self.assertEqual(bmlp.ERROR, r2.level)
コード例 #8
0
    def test_message(self):
        l = {
            "level": "info",
            "ts": 1589379832.5167677,
            "logger": "cmd",
            "msg": "Go Version: go1.13.8"
        }
        r = bmlp.Record(l)

        self.assertEqual('Go Version: go1.13.8', r.message)
コード例 #9
0
 def test_name_ppimg(self):
     i = {
         "level": "info",
         "ts": 1643928194.57431,
         "logger": "controllers.PreprovisioningImage",
         "msg": "updating status",
         "preprovisioningimage": "metal3/somehost"
     }
     image = bmlp.Record(i)
     self.assertEqual('somehost', image.name)
コード例 #10
0
 def test_name_hfs(self):
     f = {
         "level": "info",
         "ts": 1644553362.482095,
         "logger": "controllers.HostFirmwareSettings",
         "msg": "start",
         "hostfirmwaresettings": "metal3/somehost"
     }
     hfs = bmlp.Record(f)
     self.assertEqual('somehost', hfs.name)
コード例 #11
0
    def test_logger(self):
        l = {
            "level": "info",
            "ts": 1589379832.5167677,
            "logger": "cmd",
            "msg": ""
        }
        r = bmlp.Record(l)

        self.assertIn(r.logger, bmlp.COMMAND)
コード例 #12
0
    def test_format(self):
        l = {
            "level": "info",
            "ts": 1589379832.5167677,
            "logger": "cmd",
            "msg": "Go Version: go1.13.8"
        }
        r = bmlp.Record(l)

        self.assertEqual('2020-05-13T14:23:52.516 Go Version: go1.13.8',
                         r.format())
コード例 #13
0
    def test_format_noextra_highlight(self):
        l = {
            "level": "info",
            "ts": 1589379832.873149,
            "logger": "baremetalhost_ironic",
            "msg": "ironic settings"
        }
        r = bmlp.Record(l)

        self.assertEqual(
            '\033[37m2020-05-13T14:23:52.873 \033[39mironic settings\033[39m',
            r.format(highlight=True))
コード例 #14
0
    def test_data(self):
        b = {
            "level": "info",
            "ts": 1589380774.1207273,
            "logger": "baremetalhost",
            "msg": "Reconciling BareMetalHost",
            "Request.Namespace": "metal3",
            "Request.Name": "somehost"
        }
        r = bmlp.Record(b)

        self.assertSetEqual({'Request.Namespace', 'Request.Name'},
                            set(r.data.keys()))
コード例 #15
0
    def test_format_error_highlight(self):
        e = {
            "level": "error",
            "ts": 1589381055.1638162,
            "logger": "controller-runtime.controller",
            "msg": "Reconciler error",
            "request": "metal3/somehost"
        }
        r = bmlp.Record(e)

        self.assertEqual(
            '\033[91m2020-05-13T14:44:15.163 \033[31mReconciler error\033[91m '
            "{request: 'metal3/somehost'}\033[39m", r.format(highlight=True))
コード例 #16
0
    def test_timestamp(self):
        l = {
            "level": "info",
            "ts": 1589379832.5167677,
            "logger": "cmd",
            "msg": ""
        }
        r = bmlp.Record(l)

        self.assertEqual(
            datetime.datetime(2020, 5, 13, 14, 23, 52, 516768,
                              datetime.timezone.utc), r.timestamp)

        output = r.format()
        self.assertEqual('2020-05-13T14:23:52.516',
                         output.format().split(' ')[0])
コード例 #17
0
 def test_hardware_details(self):
     l = {
         "level": "info",
         "ts": 1590157176.3108344,
         "logger": "baremetalhost_ironic",
         "msg": "received introspection data",
         "data": {
             "cpu": {
                 "architecture": "x86_64",
                 "count": 1
             }
         }
     }
     r = bmlp.Record(l)
     self.assertEqual('cpu:\n  architecture: x86_64\n  count: 1\n',
                      r.context)
コード例 #18
0
    def test_format_highlight(self):
        l = {
            "level": "info",
            "ts": 1589379832.873149,
            "logger": "baremetalhost_ironic",
            "msg": "ironic settings",
            "endpoint": "http://172.30.0.47:6385/v1/",
            "inspectorEndpoint": "http://172.30.0.47:5050/v1/",
            "deployKernelURL": "http://172.30.0.47:6180/images/ipa.kernel",
            "deployRamdiskURL": "http://172.30.0.47:6180/images/initramfs"
        }
        r = bmlp.Record(l)

        self.assertEqual(
            '\033[37m2020-05-13T14:23:52.873 \033[39mironic settings\033[37m {'
            "endpoint: 'http://172.30.0.47:6385/v1/', "
            "inspectorEndpoint: 'http://172.30.0.47:5050/v1/', "
            "deployKernelURL: 'http://172.30.0.47:6180/images/ipa.kernel', "
            "deployRamdiskURL: 'http://172.30.0.47:6180/images/initramfs'}"
            "\033[39m", r.format(highlight=True))
コード例 #19
0
    def test_name(self):
        c = {
            "level": "info",
            "ts": 1589379832.5167677,
            "logger": "cmd",
            "msg": ""
        }
        cmd = bmlp.Record(c)
        self.assertIsNone(cmd.name)

        r = {
            "level": "info",
            "ts": 1589379832.872805,
            "logger": "controller-runtime.metrics",
            "msg": "metrics server is starting to listen",
            "addr": "127.0.0.1:8085"
        }
        runtime = bmlp.Record(r)
        self.assertIsNone(runtime.name)

        i = {
            "level": "info",
            "ts": 1589379832.873149,
            "logger": "baremetalhost_ironic",
            "msg": "ironic settings",
            "endpoint": "http://172.30.0.47:6385/v1/",
            "inspectorEndpoint": "http://172.30.0.47:5050/v1/",
            "deployKernelURL": "http://172.30.0.47:6180/images/ipa.kernel",
            "deployRamdiskURL": "http://172.30.0.47:6180/images/initramfs"
        }
        ironic = bmlp.Record(i)
        self.assertIsNone(ironic.name)

        ip = {
            "level": "info",
            "ts": 1589380774.1379526,
            "logger": "baremetalhost_ironic",
            "msg": "validating management access",
            "host": "somehost"
        }
        ironic_prov = bmlp.Record(ip)
        self.assertEqual('somehost', ironic_prov.name)

        ip_ns = {
            "level": "info",
            "ts": 1589380774.1379526,
            "logger": "baremetalhost_ironic",
            "msg": "validating management access",
            "host": "metal3~somehost"
        }
        ironic_prov_ns = bmlp.Record(ip_ns)
        self.assertEqual('somehost', ironic_prov_ns.name)

        b = {
            "level": "info",
            "ts": 1589380774.1207273,
            "logger": "baremetalhost",
            "msg": "Reconciling BareMetalHost",
            "Request.Namespace": "metal3",
            "Request.Name": "somehost"
        }
        bmh = bmlp.Record(b)
        self.assertEqual('somehost', bmh.name)

        e = {
            "level":
            "error",
            "ts":
            1589381055.1638162,
            "logger":
            "controller-runtime.controller",
            "msg":
            "Reconciler error",
            "controller":
            "metal3-baremetalhost-controller",
            "request":
            "metal3/somehost",
            "error":
            "failed to save host status after \"ready\".",
            "stacktrace":
            "github.com/go-logr/zapr.(*zapLogger).Error\n"
            "\t/go/pkg/mod/github.com/go-logr/[email protected]/zapr.go:128"
        }
        err = bmlp.Record(e)
        self.assertEqual('somehost', err.name)

        se = {
            "level":
            "error",
            "ts":
            1589381055.1638162,
            "logger":
            "controller-runtime.source",
            "msg":
            "if kind is a CRD, in should be installed before calling Start",
            "kind":
            "BaremetalHost.metal3.io",
            "error":
            "no matches for kind \"BaremetalHost\" in"
            "version \"metal3.io/v1alpha1\"",
            "stacktrace":
            "sigs.k8s.io/controller-runtime/pkg/source.(*Kind).Start.func1\n"
            "\t/go/src/github.com/metal3-io/baremetal-operator/vendor/sigs.k8s.io/controller-runtime/pkg/source/source.go:128"
        }
        err = bmlp.Record(se)
        self.assertIsNone(err.name)
コード例 #20
0
    def test_namespace(self):
        c = {
            "level": "info",
            "ts": 1589379832.5167677,
            "logger": "cmd",
            "msg": ""
        }
        cmd = bmlp.Record(c)
        self.assertIsNone(cmd.name)

        r = {
            "level": "info",
            "ts": 1589379832.872805,
            "logger": "controller-runtime.metrics",
            "msg": "metrics server is starting to listen",
            "addr": "127.0.0.1:8085"
        }
        runtime = bmlp.Record(r)
        self.assertIsNone(runtime.namespace)

        i = {
            "level": "info",
            "ts": 1589379832.873149,
            "logger": "baremetalhost_ironic",
            "msg": "ironic settings",
            "endpoint": "http://172.30.0.47:6385/v1/",
            "inspectorEndpoint": "http://172.30.0.47:5050/v1/",
            "deployKernelURL": "http://172.30.0.47:6180/images/ipa.kernel",
            "deployRamdiskURL": "http://172.30.0.47:6180/images/initramfs"
        }
        ironic = bmlp.Record(i)
        self.assertIsNone(ironic.namespace)

        ip = {
            "level": "info",
            "ts": 1589380774.1379526,
            "logger": "baremetalhost_ironic",
            "msg": "validating management access",
            "host": "somehost"
        }
        ironic_prov = bmlp.Record(ip)
        self.assertEqual(None, ironic_prov.namespace)

        ip_ns = {
            "level": "info",
            "ts": 1589380774.1379526,
            "logger": "baremetalhost_ironic",
            "msg": "validating management access",
            "host": "metal3~somehost"
        }
        ironic_prov_ns = bmlp.Record(ip_ns)
        self.assertEqual('metal3', ironic_prov_ns.namespace)

        b = {
            "level": "info",
            "ts": 1589380774.1207273,
            "logger": "baremetalhost",
            "msg": "Reconciling BareMetalHost",
            "Request.Namespace": "metal3",
            "Request.Name": "somehost"
        }
        bmh = bmlp.Record(b)
        self.assertEqual('metal3', bmh.namespace)

        e = {
            "level":
            "error",
            "ts":
            1589381055.1638162,
            "logger":
            "controller-runtime.controller",
            "msg":
            "Reconciler error",
            "controller":
            "metal3-baremetalhost-controller",
            "request":
            "metal3/somehost",
            "error":
            "failed to save host status after \"ready\".",
            "stacktrace":
            "github.com/go-logr/zapr.(*zapLogger).Error\n"
            "\t/go/pkg/mod/github.com/go-logr/[email protected]/zapr.go:128"
        }
        err = bmlp.Record(e)
        self.assertEqual('metal3', err.namespace)