synapse 2.154.1__py311-none-any.whl → 2.156.0__py311-none-any.whl

synapse/tests/test_lib_storm.py

@@ -463,6 +463,17 @@ class StormTest(s_t_utils.SynTest):
             ''')
             self.stormIsInPrint('caught err=', msgs)
 
+            # Non-runtsafe Storm works without inbound nodes
+            msgs = await core.stormlist('''
+            try {
+                [ inet:ipv4=0 ]
+                $lib.raise(foo, $node.repr())
+            } catch * as err {
+                $lib.print($err.mesg)
+            }
+            ''')
+            self.stormIsInPrint('0.0.0.0', msgs)
+
             # info must be json safe
             with self.raises(s_exc.MustBeJsonSafe):
                 await core.callStorm('$x="foo" $x=$x.encode() $lib.raise(foo, test, bar=$x)')
@@ -559,7 +570,7 @@ class StormTest(s_t_utils.SynTest):
             self.true(all([n.get('name') == 'foo' for n in nodes]))
 
             # Runtsafety test
-            q = '[ inet:fqdn=www.vertex.link ] $q={ :domain -> inet:fqdn } | parallel $q'
+            q = '[ inet:fqdn=www.vertex.link ] $q=:domain | parallel $q'
             await self.asyncraises(s_exc.StormRuntimeError, core.nodes(q))
 
             # test $lib.exit() and the StormExit handlers
@@ -2070,7 +2081,7 @@ class StormTest(s_t_utils.SynTest):
             await self.asyncraises(s_exc.StormRuntimeError, core.nodes(q))
 
             # Runtsafety test
-            q = '[ inet:fqdn=www.vertex.link ] $q={ :domain -> inet:fqdn } | tree $q'
+            q = '[ inet:fqdn=www.vertex.link ] $q=:domain | tree $q'
             await self.asyncraises(s_exc.StormRuntimeError, core.nodes(q))
 
     async def test_storm_movetag(self):
@@ -2324,16 +2335,6 @@ class StormTest(s_t_utils.SynTest):
             self.len(0, await core.nodes('[ test:str=foo test:str=bar ] | spin'))
             self.len(2, await core.nodes('test:str=foo test:str=bar'))
 
-    async def test_storm_reindex_sudo(self):
-
-        async with self.getTestCore() as core:
-
-            mesgs = await core.stormlist('reindex')
-            self.stormIsInWarn('reindex currently does nothing', mesgs)
-
-            msgs = await core.stormlist('.created | sudo')
-            self.stormIsInWarn('sudo command is deprecated and will be removed on 2023-10-01', msgs)
-
     async def test_storm_count(self):
 
         async with self.getTestCore() as core:
@@ -2864,7 +2865,7 @@ class StormTest(s_t_utils.SynTest):
                 await core.nodes(q)
 
             # Runtsafety test
-            q = '[ inet:fqdn=www.vertex.link ] $q={ :domain -> inet:fqdn } | tee $q'
+            q = '[ inet:fqdn=www.vertex.link ] $q=:domain | tee $q'
             await self.asyncraises(s_exc.StormRuntimeError, core.nodes(q))
 
     async def test_storm_yieldvalu(self):
@@ -2969,300 +2970,6 @@ class StormTest(s_t_utils.SynTest):
             nodes = await core.nodes(q, opts={'view': fork, 'vars': {'view': view}})
             self.len(1, nodes)
 
-    async def test_storm_splicelist(self):
-
-        async with self.getTestCoreAndProxy() as (core, prox):
-
-            mesgs = await core.stormlist('[ test:str=foo ]')
-            await asyncio.sleep(0.01)
-
-            mesgs = await core.stormlist('[ test:str=bar ]')
-
-            tick = mesgs[0][1]['tick']
-            tickdt = datetime.datetime.fromtimestamp(tick / 1000.0, datetime.UTC)
-            tickstr = tickdt.strftime('%Y/%m/%d %H:%M:%S.%f')
-
-            tock = mesgs[-1][1]['tock']
-            tockdt = datetime.datetime.fromtimestamp(tock / 1000.0, datetime.UTC)
-            tockstr = tockdt.strftime('%Y/%m/%d %H:%M:%S.%f')
-
-            await asyncio.sleep(0.01)
-            mesgs = await core.stormlist('[ test:str=baz ]')
-
-            nodes = await core.nodes(f'splice.list')
-            self.len(9, nodes)
-
-            nodes = await core.nodes(f'splice.list --mintimestamp {tick}')
-            self.len(4, nodes)
-
-            nodes = await core.nodes(f'splice.list --mintime "{tickstr}"')
-            self.len(4, nodes)
-
-            nodes = await core.nodes(f'splice.list --maxtimestamp {tock}')
-            self.len(7, nodes)
-
-            nodes = await core.nodes(f'splice.list --maxtime "{tockstr}"')
-            self.len(7, nodes)
-
-            nodes = await core.nodes(f'splice.list --mintimestamp {tick} --maxtimestamp {tock}')
-            self.len(2, nodes)
-
-            nodes = await core.nodes(f'splice.list --mintime "{tickstr}" --maxtime "{tockstr}"')
-            self.len(2, nodes)
-
-            await self.asyncraises(s_exc.StormRuntimeError, core.nodes('splice.list --mintime badtime'))
-            await self.asyncraises(s_exc.StormRuntimeError, core.nodes('splice.list --maxtime nope'))
-
-            visi = await prox.addUser('visi', passwd='secret')
-
-            await prox.addUserRule(visi['iden'], (True, ('node', 'add')))
-            await prox.addUserRule(visi['iden'], (True, ('node', 'prop', 'set')))
-
-            async with core.getLocalProxy(user='visi') as asvisi:
-
-                # make sure a normal user only gets their own splices
-                nodes = await alist(asvisi.eval("[ test:str=hehe ]"))
-
-                nodes = await alist(asvisi.eval("splice.list"))
-                self.len(2, nodes)
-
-                # should get all splices now as an admin
-                await prox.setUserAdmin(visi['iden'], True)
-
-                nodes = await alist(asvisi.eval("splice.list"))
-                self.len(11, nodes)
-
-            msgs = await core.stormlist('splice.undo')
-            self.stormIsInWarn('deprecated', msgs)
-
-    async def test_storm_spliceundo(self):
-
-        self.skip('order is different and this is deprecated')
-        async with self.getTestCoreAndProxy() as (core, prox):
-
-            await core.addTagProp('risk', ('int', {'min': 0, 'max': 100}), {'doc': 'risk score'})
-
-            visi = await prox.addUser('visi', passwd='secret')
-
-            await prox.addUserRule(visi['iden'], (True, ('node', 'add')))
-            await prox.addUserRule(visi['iden'], (True, ('node', 'prop', 'set')))
-            await prox.addUserRule(visi['iden'], (True, ('node', 'tag', 'add')))
-
-            async with core.getLocalProxy(user='visi') as asvisi:
-
-                nodes = await alist(asvisi.eval("[ test:str=foo ]"))
-                await asyncio.sleep(0.01)
-
-                mesgs = await alist(asvisi.storm("[ test:str=bar ]"))
-                tick = mesgs[0][1]['tick']
-                tock = mesgs[-1][1]['tock']
-
-                mesgs = await alist(asvisi.storm("test:str=bar [ +#test.tag ]"))
-
-                # undo a node add
-
-                nodes = await alist(asvisi.eval("test:str=bar"))
-                self.len(1, nodes)
-
-                # undo adding a node fails without tag:del perms if is it tagged
-                q = f'splice.list --mintimestamp {tick} --maxtimestamp {tock} | splice.undo'
-                await self.agenraises(s_exc.AuthDeny, asvisi.eval(q))
-
-                await prox.addUserRule(visi['iden'], (True, ('node', 'tag', 'del')))
-
-                # undo adding a node fails without node:del perms
-                q = f'splice.list --mintimestamp {tick} --maxtimestamp {tock} | splice.undo'
-                await self.agenraises(s_exc.AuthDeny, asvisi.eval(q))
-
-                await prox.addUserRule(visi['iden'], (True, ('node', 'del')))
-                nodes = await alist(asvisi.eval(q))
-
-                nodes = await alist(asvisi.eval("test:str=bar"))
-                self.len(0, nodes)
-
-                # undo a node delete
-
-                # undo deleting a node fails without node:add perms
-                await prox.delUserRule(visi['iden'], (True, ('node', 'add')))
-
-                q = 'splice.list | limit 2 | splice.undo'
-                await self.agenraises(s_exc.AuthDeny, asvisi.eval(q))
-
-                await prox.addUserRule(visi['iden'], (True, ('node', 'add')))
-                nodes = await alist(asvisi.eval(q))
-
-                nodes = await alist(asvisi.eval("test:str=bar"))
-                self.len(1, nodes)
-
-                # undo adding a prop
-
-                nodes = await alist(asvisi.eval("test:str=foo [ :tick=2000 ]"))
-                self.nn(nodes[0][1]['props'].get('tick'))
-
-                # undo adding a prop fails without prop:del perms
-                q = 'splice.list | limit 1 | splice.undo'
-                await self.agenraises(s_exc.AuthDeny, asvisi.eval(q))
-
-                await prox.addUserRule(visi['iden'], (True, ('node', 'prop', 'del',)))
-                nodes = await alist(asvisi.eval(q))
-
-                nodes = await alist(asvisi.eval("test:str=foo"))
-                self.none(nodes[0][1]['props'].get('tick'))
-
-                # undo updating a prop
-
-                nodes = await alist(asvisi.eval("test:str=foo [ :tick=2000 ]"))
-                oldv = nodes[0][1]['props']['tick']
-                self.nn(oldv)
-
-                nodes = await alist(asvisi.eval("test:str=foo [ :tick=3000 ]"))
-                self.ne(oldv, nodes[0][1]['props']['tick'])
-
-                # undo updating a prop fails without prop:set perms
-                await prox.delUserRule(visi['iden'], (True, ('node', 'prop', 'set')))
-
-                q = 'splice.list | limit 1 | splice.undo'
-                await self.agenraises(s_exc.AuthDeny, asvisi.eval(q))
-
-                await prox.addUserRule(visi['iden'], (True, ('node', 'prop', 'set',)))
-                nodes = await alist(asvisi.eval(q))
-
-                nodes = await alist(asvisi.eval("test:str=foo"))
-                self.eq(oldv, nodes[0][1]['props']['tick'])
-
-                # undo deleting a prop
-
-                nodes = await alist(asvisi.eval("test:str=foo [ -:tick ]"))
-                self.none(nodes[0][1]['props'].get('tick'))
-
-                # undo deleting a prop fails without prop:set perms
-                await prox.delUserRule(visi['iden'], (True, ('node', 'prop', 'set')))
-
-                q = 'splice.list | limit 1 | splice.undo'
-                await self.agenraises(s_exc.AuthDeny, asvisi.eval(q))
-
-                await prox.addUserRule(visi['iden'], (True, ('node', 'prop', 'set')))
-                nodes = await alist(asvisi.eval(q))
-
-                nodes = await alist(asvisi.eval("test:str=foo"))
-                self.eq(oldv, nodes[0][1]['props']['tick'])
-
-                # undo adding a tag
-
-                nodes = await alist(asvisi.eval("test:str=foo [ +#rep=2000 ]"))
-                tagv = nodes[0][1]['tags'].get('rep')
-                self.nn(tagv)
-
-                # undo adding a tag fails without tag:del perms
-                await prox.delUserRule(visi['iden'], (True, ('node', 'tag', 'del',)))
-
-                q = 'splice.list | limit 1 | splice.undo'
-                await self.agenraises(s_exc.AuthDeny, asvisi.eval(q))
-
-                await prox.addUserRule(visi['iden'], (True, ('node', 'tag', 'del',)))
-                nodes = await alist(asvisi.eval(q))
-
-                nodes = await alist(asvisi.eval("test:str=foo"))
-                self.none(nodes[0][1]['tags'].get('rep'))
-
-                # undo deleting a tag
-
-                # undo deleting a tag fails without tag:add perms
-                await prox.delUserRule(visi['iden'], (True, ('node', 'tag', 'add')))
-
-                q = 'splice.list | limit 1 | splice.undo'
-                await self.agenraises(s_exc.AuthDeny, asvisi.eval(q))
-
-                await prox.addUserRule(visi['iden'], (True, ('node', 'tag', 'add')))
-                nodes = await alist(asvisi.eval(q))
-
-                nodes = await alist(asvisi.eval("test:str=foo"))
-                self.eq(tagv, nodes[0][1]['tags'].get('rep'))
-
-                # undo updating a tag
-                nodes = await alist(asvisi.eval("test:str=foo [ +#rep=2000 ]"))
-                oldv = nodes[0][1]['tags'].get('rep')
-                nodes = await alist(asvisi.eval("test:str=foo [ +#rep=3000 ]"))
-                self.ne(oldv, nodes[0][1]['tags'].get('rep'))
-
-                q = 'splice.list | limit 1 | splice.undo'
-                await alist(asvisi.eval(q))
-
-                nodes = await alist(asvisi.eval("test:str=foo"))
-                self.eq(oldv, nodes[0][1]['tags'].get('rep'))
-
-                # undo adding a tagprop
-
-                nodes = await alist(asvisi.eval("test:str=foo [ +#rep:risk=50 ]"))
-                tagv = nodes[0][1]['tagprops']['rep'].get('risk')
-                self.nn(tagv)
-
-                # undo adding a tagprop fails without tag:del perms
-                await prox.delUserRule(visi['iden'], (True, ('node', 'tag', 'del')))
-
-                q = 'splice.list | limit 1 | splice.undo'
-                await self.agenraises(s_exc.AuthDeny, asvisi.eval(q))
-
-                await prox.addUserRule(visi['iden'], (True, ('node', 'tag', 'del')))
-                nodes = await alist(asvisi.eval(q))
-
-                nodes = await alist(asvisi.eval("test:str=foo"))
-                self.none(nodes[0][1]['tagprops'].get('rep'))
-
-                # undo deleting a tagprop
-
-                # undo deleting a tagprop fails without tag:add perms
-                await prox.delUserRule(visi['iden'], (True, ('node', 'tag', 'add')))
-
-                q = 'splice.list | limit 1 | splice.undo'
-                await self.agenraises(s_exc.AuthDeny, asvisi.eval(q))
-
-                await prox.addUserRule(visi['iden'], (True, ('node', 'tag', 'add')))
-                nodes = await alist(asvisi.eval(q))
-
-                nodes = await alist(asvisi.eval("test:str=foo"))
-                self.eq(tagv, nodes[0][1]['tagprops']['rep'].get('risk'))
-
-                # undo updating a tagprop
-
-                nodes = await alist(asvisi.eval("test:str=foo [ +#rep:risk=0 ]"))
-                self.ne(tagv, nodes[0][1]['tagprops']['rep'].get('risk'))
-
-                # undo updating a tagprop fails without prop:set perms
-                await prox.delUserRule(visi['iden'], (True, ('node', 'tag', 'add')))
-
-                q = 'splice.list | limit 1 | splice.undo'
-                await self.agenraises(s_exc.AuthDeny, asvisi.eval(q))
-
-                await prox.addUserRule(visi['iden'], (True, ('node', 'tag', 'add')))
-                nodes = await alist(asvisi.eval(q))
-
-                nodes = await alist(asvisi.eval("test:str=foo"))
-                self.eq(tagv, nodes[0][1]['tagprops']['rep'].get('risk'))
-
-                # sending nodes of form other than syn:splice doesn't work
-                q = 'test:str | limit 1 | splice.undo'
-                await self.agenraises(s_exc.StormRuntimeError, asvisi.eval(q))
-
-                # must be admin to use --force for node deletion
-                await alist(asvisi.eval('[ test:cycle0=foo :cycle1=bar ]'))
-                await alist(asvisi.eval('[ test:cycle1=bar :cycle0=foo ]'))
-
-                nodes = await alist(asvisi.eval("test:cycle0"))
-                self.len(1, nodes)
-
-                q = 'splice.list | +:type="node:add" +:form="test:cycle0" | limit 1 | splice.undo'
-                await self.agenraises(s_exc.CantDelNode, asvisi.eval(q))
-
-                q = 'splice.list | +:type="node:add" +:form="test:cycle0" | limit 1 | splice.undo --force'
-                await self.agenraises(s_exc.AuthDeny, asvisi.eval(q))
-
-                await prox.setUserAdmin(visi['iden'], True)
-
-                nodes = await alist(asvisi.eval(q))
-                nodes = await alist(asvisi.eval("test:cycle0"))
-                self.len(0, nodes)
-
     async def test_storm_argv_parser(self):
 
         pars = s_storm.Parser(prog='hehe')
@@ -4353,12 +4060,12 @@ class StormTest(s_t_utils.SynTest):
             await core.nodes('runas visi { [ inet:fqdn=bar.com ] }')
 
             items = await alist(core.syncLayersEvents({}, wait=False))
-            self.len(4, [item for item in items if item[-1]['user'] == visi.iden])
+            self.len(2, [item for item in items if item[-1]['user'] == visi.iden])
 
             await core.nodes(f'runas {visi.iden} {{ [ inet:fqdn=baz.com ] }}')
 
             items = await alist(core.syncLayersEvents({}, wait=False))
-            self.len(8, [item for item in items if item[-1]['user'] == visi.iden])
+            self.len(4, [item for item in items if item[-1]['user'] == visi.iden])
 
             q = 'inet:fqdn $n=$node runas visi { yield $n [ +#atag ] }'
             await self.asyncraises(s_exc.AuthDeny, core.nodes(q))

synapse/tests/test_lib_stormlib_gis.py

@@ -0,0 +1,21 @@
+import synapse.exc as s_exc
+
+import synapse.tests.utils as s_test
+
+class StormLibGisTest(s_test.SynTest):
+
+    async def test_stormlib_gis_bbox(self):
+
+        async with self.getTestCore() as core:
+
+            lbox = await core.callStorm('return($lib.gis.bbox(-2.0783, 51.8994, $lib.cast(geo:dist, 1km)))')
+            self.eq(lbox, (-2.0928746526154747,
+                           -2.0637253473845254,
+                           51.890406796362754,
+                           51.908393203637246))
+
+            with self.raises(s_exc.BadArg):
+                lbox = await core.callStorm('return($lib.gis.bbox(newp, -2.0783, 1))')
+
+            with self.raises(s_exc.BadArg):
+                lbox = await core.callStorm('return($lib.gis.bbox(51.2, -2.0783, newp))')

synapse/tests/test_lib_stormlib_stats.py

@@ -4,57 +4,116 @@ import synapse.tests.utils as s_test
 import synapse.lib.stormlib.stats as s_stormlib_stats
 
 chartnorm = '''
-40 | 5 | ##################################################
-30 | 4 | ########################################
-20 | 3 | ##############################
+ 6 | 5 | ##################################################
+13 | 4 | ########################################
+ 3 | 3 | ##############################
 10 | 2 | ####################
  0 | 1 | ##########
 '''.strip()
 
+chartnorm_byname = '''
+13 | 4 | ########################################
+10 | 2 | ####################
+ 6 | 5 | ##################################################
+ 3 | 3 | ##############################
+ 0 | 1 | ##########
+'''.strip()
+
 chartrev = '''
  0 | 1 | ##########
 10 | 2 | ####################
-20 | 3 | ##############################
-30 | 4 | ########################################
-40 | 5 | ##################################################
+ 3 | 3 | ##############################
+13 | 4 | ########################################
+ 6 | 5 | ##################################################
+'''.strip()
+
+chartrev_byname = '''
+ 0 | 1 | ##########
+ 3 | 3 | ##############################
+ 6 | 5 | ##################################################
+10 | 2 | ####################
+13 | 4 | ########################################
 '''.strip()
 
 chartsize = '''
-40 | 5 | ##################################################
-30 | 4 | ########################################
-20 | 3 | ##############################
+ 6 | 5 | ##################################################
+13 | 4 | ########################################
+ 3 | 3 | ##############################
+'''.strip()
+
+chartsize_byname = '''
+13 | 4 | ########################################
+10 | 2 | ####################
+ 6 | 5 | ##################################################
 '''.strip()
 
 chartsizerev = '''
  0 | 1 | ##########
 10 | 2 | ####################
-20 | 3 | ##############################
+ 3 | 3 | ##############################
+'''.strip()
+
+chartsizerev_byname = '''
+0 | 1 | ##########
+3 | 3 | ##############################
+6 | 5 | ##################################################
 '''.strip()
 
 chartwidth = '''
-40 | 5 | ##########
-30 | 4 | ########
-20 | 3 | ######
+ 6 | 5 | ##########
+13 | 4 | ########
+ 3 | 3 | ######
 10 | 2 | ####
  0 | 1 | ##
 '''.strip()
 
+chartwidth_byname = '''
+13 | 4 | ########
+10 | 2 | ####
+ 6 | 5 | ##########
+ 3 | 3 | ######
+ 0 | 1 | ##
+'''.strip()
+
 chartlabelwidth = '''
-4 | 5 | ##################################################
-3 | 4 | ########################################
-2 | 3 | ##############################
+6 | 5 | ##################################################
+1 | 4 | ########################################
+3 | 3 | ##############################
 1 | 2 | ####################
 0 | 1 | ##########
 '''.strip()
 
+chartlabelwidth_byname = '''
+1 | 4 | ########################################
+1 | 2 | ####################
+6 | 5 | ##################################################
+3 | 3 | ##############################
+0 | 1 | ##########
+'''.strip()
+
 chartchar = '''
-40 | 5 | ++++++++++++++++++++++++++++++++++++++++++++++++++
-30 | 4 | ++++++++++++++++++++++++++++++++++++++++
-20 | 3 | ++++++++++++++++++++++++++++++
+ 6 | 5 | ++++++++++++++++++++++++++++++++++++++++++++++++++
+13 | 4 | ++++++++++++++++++++++++++++++++++++++++
+ 3 | 3 | ++++++++++++++++++++++++++++++
 10 | 2 | ++++++++++++++++++++
  0 | 1 | ++++++++++
 '''.strip()
 
+chartchar_byname = '''
+13 | 4 | ++++++++++++++++++++++++++++++++++++++++
+10 | 2 | ++++++++++++++++++++
+ 6 | 5 | ++++++++++++++++++++++++++++++++++++++++++++++++++
+ 3 | 3 | ++++++++++++++++++++++++++++++
+ 0 | 1 | ++++++++++
+'''.strip()
+
+chartipv4_byname = '''
+ 0.0.0.6 | 1 | ##################################################
+ 0.0.0.2 | 1 | ##################################################
+0.0.0.10 | 1 | ##################################################
+ 0.0.0.1 | 1 | ##################################################
+'''.strip()
+
 
 class StatsTest(s_test.SynTest):
 
@@ -66,7 +125,7 @@ class StatsTest(s_test.SynTest):
             $i = (0)
             for $x in $lib.range(5) {
                 for $y in $lib.range(($x + 1)) {
-                    [ inet:ipv4=$i :asn=($x * 10) ]
+                    [ inet:ipv4=$i :asn=(($x * 10) % 17) ]
                     $i = ($i + 1)
                 }
             }
@@ -76,27 +135,55 @@ class StatsTest(s_test.SynTest):
             msgs = await core.stormlist('inet:ipv4 | stats.countby :asn')
             self.stormIsInPrint(chartnorm, msgs)
 
+            msgs = await core.stormlist('inet:ipv4 | stats.countby :asn --by-name')
+            self.stormIsInPrint(chartnorm_byname, msgs)
+
             msgs = await core.stormlist('inet:ipv4 -> inet:asn | stats.countby')
             self.stormIsInPrint(chartnorm, msgs)
 
+            msgs = await core.stormlist('inet:ipv4 -> inet:asn | stats.countby --by-name')
+            self.stormIsInPrint(chartnorm_byname, msgs)
+
             msgs = await core.stormlist('inet:ipv4 | stats.countby :asn --reverse')
             self.stormIsInPrint(chartrev, msgs)
 
+            msgs = await core.stormlist('inet:ipv4 | stats.countby :asn --reverse --by-name')
+            self.stormIsInPrint(chartrev_byname, msgs)
+
             msgs = await core.stormlist('inet:ipv4 | stats.countby :asn --size 3')
             self.stormIsInPrint(chartsize, msgs)
 
+            msgs = await core.stormlist('inet:ipv4 | stats.countby :asn --size 3 --by-name')
+            self.stormIsInPrint(chartsize_byname, msgs)
+
             msgs = await core.stormlist('inet:ipv4 | stats.countby :asn --size 3 --reverse')
             self.stormIsInPrint(chartsizerev, msgs)
 
+            msgs = await core.stormlist('inet:ipv4 | stats.countby :asn --size 3 --reverse --by-name')
+            self.stormIsInPrint(chartsizerev_byname, msgs)
+
             msgs = await core.stormlist(f'inet:ipv4 | stats.countby :asn --bar-width 10')
             self.stormIsInPrint(chartwidth, msgs)
 
+            msgs = await core.stormlist(f'inet:ipv4 | stats.countby :asn --bar-width 10 --by-name')
+            self.stormIsInPrint(chartwidth_byname, msgs)
+
             msgs = await core.stormlist(f'inet:ipv4 | stats.countby :asn --label-max-width 1')
             self.stormIsInPrint(chartlabelwidth, msgs)
 
+            msgs = await core.stormlist(f'inet:ipv4 | stats.countby :asn --label-max-width 1 --by-name')
+            self.stormIsInPrint(chartlabelwidth_byname, msgs)
+
             msgs = await core.stormlist('inet:ipv4 | stats.countby :asn --char "+"')
             self.stormIsInPrint(chartchar, msgs)
 
+            msgs = await core.stormlist('inet:ipv4 | stats.countby :asn --char "+" --by-name')
+            self.stormIsInPrint(chartchar_byname, msgs)
+
+            msgs = await core.stormlist(
+                'inet:ipv4=0.0.0.1 inet:ipv4=0.0.0.2 inet:ipv4=0.0.0.6 inet:ipv4=0.0.0.10 | stats.countby --by-name')
+            self.stormIsInPrint(chartipv4_byname, msgs)
+
             msgs = await core.stormlist('stats.countby foo')
             self.stormIsInPrint('No values to display!', msgs)
 

synapse/tests/test_lib_stormlib_storm.py

@@ -36,3 +36,28 @@ class LibStormTest(s_test.SynTest):
 
             with self.raises(s_exc.IsReadOnly):
                 await core.callStorm('$lib.storm.eval( "{$lib.auth.users.add(readonly)}" )', opts={'readonly': True})
+
+            with self.getLoggerStream('synapse.storm') as stream:
+                q = '''{
+                    $lib.log.info(hehe)
+                    [test:str=omg]
+                    $lib.log.info($node)
+                    fini { return(wow) }
+                }
+                '''
+
+                core.stormlog = True
+                opts = {'vars': {'q': q}}
+                ret = await core.callStorm('return( $lib.storm.eval($q) )', opts=opts)
+                self.eq(ret, 'wow')
+                self.len(1, await core.nodes('test:str=omg'))
+
+                # Check that we saw the logs
+                stream.seek(0)
+                data = stream.read()
+
+                mesg = 'Executing storm query {return( $lib.storm.eval($q) )} as [root]'
+                self.isin(mesg, data)
+
+                mesg = f'Executing storm query via $lib.storm.eval() {{{q}}} as [root]'
+                self.isin(mesg, data)