I am inquiring about changes to the LUCI System Log view between version 24.10.5 and the 25.12 release candidates. I am running both versions on X86_64 with identical spec hardware.
What I am noticing is that on 24.10.5 (and earlier versions) that upon load of LUCI > System Log the first log entries from startup show upon load; and I can scroll through the entire log with the web browser slider to get to current entries. (The entire log is viewable from LUCI.)
Starting with 25.12.0rc3, and continuing still with (fresh install of ) rc4, once the log entries reach 1000 and beyond, only the past 1000 lines are viewable / scroll able. I first noticed this when checking the log for something and only seeing entries for the previous (approximately) 15 minute time frame.
I did find that if I query the filter, then backspace query to clear, that then the log in it’s entirety is viewable until I exit out of the System Log tab and re-enter. Then, again, only the most recent 1000 entries of the log are shown. I determined that the amount of the log viewable was consistently 1000 lines of by copying / pasting into a notepad file, which counts the lines:
Example:
Firstly, I just wanted to ask if this was by design. I wouldn't even make a post to bring this up though if it were not for a secondary issue I noticed. The issue, and reason for my post is that when banIP (version 1.8.0-r1) is running, and the log exceeds 1000 lines (but not before), that eventually (and consistently recreate-able across device restarts) are these errors when attempting search queries in System Log.
(If I disable banIP service and restart device, unable to recreate the RPC errors below, but the System Log still exhibits the 1000-entry limitation.)
Curious of the URL referenced in the above errors, I pasted it into a separate browser tab. This is what it produced:
'use strict';'require baseclass';'require request';let rpcRequestID=1;let rpcSessionID=L.env.sessionid??'00000000000000000000000000000000';let rpcBaseURL=L.url('admin/ubus');const rpcInterceptorFns=[];return baseclass.extend({call(req,cb,nobatch){let q='';if(Array.isArray(req)){if(req.length==0)
return Promise.resolve([]);for(let i=0;i<req.length;i++)
if(req[i].params)
q+='%s%s.%s'.format(q?';':'/',req[i].params[1],req[i].params[2]);}
return request.post(rpcBaseURL+q,req,{timeout:(L.env.rpctimeout??20)*1000,nobatch,credentials:true}).then(cb,cb);},parseCallReply(req,res){let msg=null;if(res instanceof Error)
return req.reject(res);try{if(!res.ok)
L.raise('RPCError','RPC call to %s/%s failed with HTTP error %d: %s',req.object,req.method,res.status,res.statusText||'?');msg=res.json();}
catch(e){return req.reject(e);}
Promise.all(rpcInterceptorFns.map(fn=>fn(msg,req))).then(this.handleCallReply.bind(this,req,msg)).catch(req.reject);},handleCallReply(req,msg){const type=Object.prototype.toString;let ret=null;try{if(!L.isObject(msg)||msg.jsonrpc!='2.0')
L.raise('RPCError','RPC call to %s/%s returned invalid message frame',req.object,req.method);if(L.isObject(msg.error)&&msg.error.code&&msg.error.message)
L.raise('RPCError','RPC call to %s/%s failed with error %d: %s',req.object,req.method,msg.error.code,msg.error.message||'?');}
catch(e){return req.reject(e);}
if(!req.object&&!req.method){ret=msg.result;}
else if(Array.isArray(msg.result)){if(req.raise&&msg.result[0]!==0)
L.raise('RPCError','RPC call to %s/%s failed with ubus code %d: %s',req.object,req.method,msg.result[0],this.getStatusText(msg.result[0]));ret=(msg.result.length>1)?msg.result[1]:msg.result[0];}
if(req.expect){for(const key in req.expect){if(ret!=null&&key!='')
ret=ret[key];if(ret==null||type.call(ret)!=type.call(req.expect[key]))
ret=req.expect[key];break;}}
if(typeof(req.filter)=='function'){req.priv[0]=ret;req.priv[1]=req.params;ret=req.filter.apply(this,req.priv);}
req.resolve(ret);},list(...args){const msg={jsonrpc:'2.0',id:rpcRequestID++,method:'list',params:args.length?args:undefined};return new Promise(L.bind(function(resolve,reject){const req={resolve,reject};this.call(msg,this.parseCallReply.bind(this,req));},this));},declare(options){return Function.prototype.bind.call(function(rpc,options,...args){return new Promise((resolve,reject)=>{let p_off=0;const params={};if(Array.isArray(options.params)){for(p_off=0;p_off<options.params.length;p_off++)
params[options.params[p_off]]=args[p_off];}else if(typeof(options.params)==='object'){const argObj=args[0];if(argObj&&typeof(argObj)==='object'){for(let key in options.params)
if(key in argObj)
params[key]=argObj[key];}
p_off=1;}
const priv=[undefined,undefined];for(;p_off<args.length;p_off++)
priv.push(args[p_off]);const req={expect:options.expect,filter:options.filter,resolve,reject,params,priv,object:options.object,method:options.method,raise:options.reject};const msg={jsonrpc:'2.0',id:rpcRequestID++,method:'call',params:[rpcSessionID,options.object,options.method,params]};rpc.call(msg,rpc.parseCallReply.bind(rpc,req),options.nobatch);});},this,this,options);},getSessionID(){return rpcSessionID;},setSessionID(sid){rpcSessionID=sid;},getBaseURL(){return rpcBaseURL;},setBaseURL(url){rpcBaseURL=url;},getStatusText(statusCode){switch(statusCode){case 0:return _('Command OK');case 1:return _('Invalid command');case 2:return _('Invalid argument');case 3:return _('Method not found');case 4:return _('Resource not found');case 5:return _('No data received');case 6:return _('Permission denied');case 7:return _('Request timeout');case 8:return _('Not supported');case 9:return _('Unspecified error');case 10:return _('Connection lost');default:return _('Unknown error code');}},addInterceptor(interceptorFn){if(typeof(interceptorFn)=='function')
rpcInterceptorFns.push(interceptorFn);return interceptorFn;},removeInterceptor(interceptorFn){const oldlen=rpcInterceptorFns.length;let i=oldlen;while(i--)
if(rpcInterceptorFns[i]===interceptorFn)
rpcInterceptorFns.splice(i,1);return(rpcInterceptorFns.length<oldlen);}});
I'm not sure if it is an issue with LUCI, banIP, or combination of both.
Also because of the RPC references in the error, could it be related to this?
I'm not a developer, so hoping someone has more insight to cause / solution or workaround. Thank you.
