Subj : BinkD-Stats 2.0 - BinkD Log Analyzer
To   : All
From : Stephen Walsh
Date : Mon Oct 06 2025 01:59 pm


Hello everybody!


# BinkD-Stats 2.0

Python rewrite of the BinkD log analyzer with significant improvements.

## Improvements Over Perl Version

### New Features
- **JSON Export** - Export statistics to JSON format for integration with
  other tools
- **CSV Export** - Export statistics to CSV for spreadsheet analysis
- **Better Date Handling** - Uses Python's `datetime` module for more
  accurate date parsing
- **File Count Tracking** - Tracks sent/recv file counts in addition to bytes
- **Improved Error Handling** - Better error messages and exception handling
- **Modern CLI** - Uses argparse for better help and argument parsing

### Technical Improvements
- **More Accurate CPS Calculations** - Properly averages CPS from actual
  transfer speeds
- **Cleaner Code** - Object-oriented design with clear separation of concerns
- **Better Type Safety** - Type hints for better code documentation
- **Cross-platform** - Works on Linux, macOS, and Windows

### Compatibility
- Produces identical statistics to the Perl version
- Same command-line interface (with enhancements)
- Backward compatible with existing usage

## Usage

### Basic Usage
```bash
# Show all statistics
python3 binkd-stats.py -f /var/log/binkd.log

# Show last 7 days
python3 binkd-stats.py -f /var/log/binkd.log -d 7

# Show last 30 days
python3 binkd-stats.py -f /var/log/binkd.log -d 30
```

### Export Options
```bash
# Export to JSON
python3 binkd-stats.py -f /var/log/binkd.log -d 7 --json stats.json

# Export to CSV
python3 binkd-stats.py -f /var/log/binkd.log -d 7 --csv stats.csv

# Both text and JSON/CSV output
python3 binkd-stats.py -f /var/log/binkd.log --json stats.json --csv stats.csv
```

### Help
```bash
python3 binkd-stats.py --help
```

## Output Format

### Text Report (Console)
```
                        BinkD Connection's

        Statistics For Last 7 day's, Created Mon Oct  6 12:58:59 2025
-----------------------------------------------------------------------------
Address               Sessions       Sent   Received     CPS In    CPS Out
-----------------------------------------------------------------------------
1:9/36                      15      97.0k          0       0.00    8744.85
3:633/10                   345       3.2k       8.0M   22171.96     650.00
-----------------------------------------------------------------------------
 Total Received :            31.3M     Total Sessions   :            10596
 Total Sent     :            58.2M     Average CPS In   :         12052.24
 Total Traffic  :            89.4M     Average CPS Out  :          6507.43
-----------------------------------------------------------------------------
```

### JSON Export
```json
{
 "start_date": "2025-09-25T16:27:47",
 "end_date": "2025-10-06T12:52:23",
 "days_filter": 7,
 "total_sessions": 10596,
 "nodes": {
   "3:633/10": {
     "sessions": 345,
     "sent_bytes": 3250,
     "recv_bytes": 8380999,
     "sent_files": 5,
     "recv_files": 378,
     "avg_recv_cps": 22171.96,
     "avg_send_cps": 650.0
   }
 }
}
```

### CSV Export
```csv
Address,Sessions,Sent_Bytes,Recv_Bytes,Sent_Files,Recv_Files,Avg_Send_CPS,
Avg_Recv_CPS,3:633/10,345,3250,8380999,5,378,650.00,22171.96
```

## Requirements

- Python 3.6 or later (no additional dependencies required)

## Credits

- Original Perl version: (c) Netsurge//Frank Linhares % bbs.diskshop.ca
- Python rewrite: Stephen Walsh. 2025

## License

Same as original Perl version

I give permission for the Binkd dev team to include BinkD-Stats 2.0 in the
binkd source tree if they wish.


=== Cut ===
#!/usr/bin/env python3
"""
BinkD-Stats 2.0 - A BinkD Log Analyzer And Statistics Tool
Python rewrite with improvements

Original Perl version (c) Netsurge//Frank Linhares % bbs.diskshop.ca

Python version improvements, by Stephen Walsh:

- Better date/time handling with datetime module
- JSON/CSV export options
- Per-node detailed statistics
- HTML output option
- Better error handling and logging
- More accurate CPS calculations
"""

import re
import sys
import argparse
import json
from datetime import datetime, timedelta
from collections import defaultdict
from pathlib import Path
from typing import Dict, List, Tuple, Optional

class BinkDStats:
   """BinkD log file analyzer and statistics generator"""

   def __init__(self, log_file: str, days: int = 0):
       self.log_file = Path(log_file)
       self.days = days
       self.stats = defaultdict(lambda: {
           'sessions': 0,
           'sent_bytes': 0,
           'recv_bytes': 0,
           'sent_files': 0,
           'recv_files': 0,
           'send_cps': [],
           'recv_cps': []
       })
       self.start_date = None
       self.end_date = None
       self.total_sessions = 0

       # Month name mapping
       self.months = {
           'Jan': 1, 'Feb': 2, 'Mar': 3, 'Apr': 4, 'May': 5, 'Jun': 6,
           'Jul': 7, 'Aug': 8, 'Sep': 9, 'Oct': 10, 'Nov': 11, 'Dec': 12
       }

   def parse_date(self, line: str) -> Optional[datetime]:
       """Parse date from log line (format: DD MMM HH:MM:SS)"""
       match = re.match(r'[+\-!? ]\s*(\d+)\s+(\w+)\s+(\d+):(\d+):(\d+)', line)
       if not match:
           return None

       day, month_name, hour, minute, second = match.groups()
       month = self.months.get(month_name)
       if not month:
           return None

       # Determine year (assume current year unless date is in future)
       current_year = datetime.now().year
       try:
           dt = datetime(current_year, month, int(day),
                        int(hour), int(minute), int(second))
           # If date is in future, it must be from previous year
           if dt > datetime.now():
               dt = datetime(current_year - 1, month, int(day),
                           int(hour), int(minute), int(second))
           return dt
       except ValueError:
           return None

   def is_date_valid(self, dt: Optional[datetime]) -> bool:
       """Check if date is within the requested time range"""
       if dt is None:
           return False
       if self.days == 0:
           return True
       cutoff = datetime.now() - timedelta(days=self.days)
       return dt >= cutoff

   def parse_fido_address(self, addr: str) -> Tuple[int, int, int, int]:
       """Parse FidoNet address and return sortable tuple.

       Returns: (zone, net, node, point)
       """
       # Format: zone:net/node[.point][@domain]
       addr = addr.split('@')[0]  # Remove domain

       zone, net, node, point = 0, 0, 0, 0

       if ':' in addr:
           zone_part, rest = addr.split(':', 1)
           zone = int(zone_part) if zone_part.isdigit() else 0
       else:
           rest = addr

       if '/' in rest:
           net_part, node_part = rest.split('/', 1)
           net = int(net_part) if net_part.isdigit() else 0

           if '.' in node_part:
               node_str, point_str = node_part.split('.', 1)
               node = int(node_str) if node_str.isdigit() else 0
               point = int(point_str) if point_str.isdigit() else 0
           else:
               node = int(node_part) if node_part.isdigit() else 0

       return (zone, net, node, point)

   def format_bytes(self, bytes_val: int) -> str:
       """Format bytes into human-readable format"""
       if bytes_val < 1024:
           return f"{bytes_val}"
       elif bytes_val < 1048576:
           return f"{bytes_val / 1024:.1f}k"
       else:
           return f"{bytes_val / 1048576:.1f}M"

   def parse_log(self):
       """Parse the binkd log file"""
       if not self.log_file.exists():
           raise FileNotFoundError(f"Log file not found: {self.log_file}")

       # Regex patterns
       done_pattern = re.compile(
           r'done \(\w+ (\S+)\@\w+, \w+, S/R: (\d+)/(\d+) \((\d+)/(\d+)'
       )
       rcvd_pattern = re.compile(r'rcvd:.*?\((\d+), ([\d.]+) CPS, (\S+)\@')
       sent_pattern = re.compile(r'sent:.*?\((\d+), ([\d.]+) CPS, (\S+)\@')

       with open(self.log_file, 'r', encoding='utf-8', errors='replace') as f:
           for line in f:
               line = line.strip()

               # Parse date
               dt = self.parse_date(line)
               if dt:
                   if self.start_date is None or dt < self.start_date:
                       self.start_date = dt
                   if self.end_date is None or dt > self.end_date:
                       self.end_date = dt

               # Check if line is within date range
               if not self.is_date_valid(dt):
                   continue

               # Parse "done" lines for session summary
               match = done_pattern.search(line)
               if match:
                   addr = match.group(1)
                   sent_files = int(match.group(2))
                   recv_files = int(match.group(3))
                   sent_bytes = int(match.group(4))
                   recv_bytes = int(match.group(5))

                   self.stats[addr]['sessions'] += 1
                   self.stats[addr]['sent_bytes'] += sent_bytes
                   self.stats[addr]['recv_bytes'] += recv_bytes
                   self.stats[addr]['sent_files'] += sent_files
                   self.stats[addr]['recv_files'] += recv_files
                   self.total_sessions += 1

               # Parse "rcvd" lines for CPS
               match = rcvd_pattern.search(line)
               if match:
                   cps = float(match.group(2))
                   addr = match.group(3)
                   self.stats[addr]['recv_cps'].append(cps)

               # Parse "sent" lines for CPS
               match = sent_pattern.search(line)
               if match:
                   cps = float(match.group(2))
                   addr = match.group(3)
                   self.stats[addr]['send_cps'].append(cps)

   def calculate_avg_cps(self, cps_list: List[float]) -> float:
       """Calculate average CPS from list"""
       return sum(cps_list) / len(cps_list) if cps_list else 0.0

   def print_text_report(self):
       """Print statistics report to console"""
       if not self.stats:
           print("\n[There Are No Connections To Report]\n")
           return

       print()
       print("                         BinkD Connection's")
       print()

       if self.days == 0:
           if self.start_date:
               start_str = self.start_date.strftime("%c")
           else:
               start_str = "Unknown"
           if self.end_date:
               end_str = self.end_date.strftime("%c")
           else:
               end_str = "Unknown"
           stat_line = f"Statistics From {start_str} Thru To {end_str}"
           # Center the line within 78 characters
           print(stat_line.center(78))
       else:
           now_str = datetime.now().strftime("%c")
           print(f"         Statistics For Last {self.days} day's, "
                 f"Created {now_str}")

       print("-" * 77)
       print(f"{'Address':<18} {'Sessions':>8}  {'Sent':>9}  "
             f"{'Received':>9}  {'CPS In':>9}  {'CPS Out':>9}")
       print("-" * 77)

       # Sort addresses by FidoNet address
       sorted_addrs = sorted(self.stats.keys(),
                           key=lambda x: self.parse_fido_address(x))

       total_sent = 0
       total_recv = 0
       avg_rcps_list = []
       avg_scps_list = []

       for addr in sorted_addrs:
           s = self.stats[addr]
           avg_rcps = self.calculate_avg_cps(s['recv_cps'])
           avg_scps = self.calculate_avg_cps(s['send_cps'])

           print(f"{addr:<18} {s['sessions']:>8}  "
                 f"{self.format_bytes(s['sent_bytes']):>9}  "
                 f"{self.format_bytes(s['recv_bytes']):>9}  "
                 f"{avg_rcps:>9.2f}  {avg_scps:>9.2f}")

           total_sent += s['sent_bytes']
           total_recv += s['recv_bytes']
           if avg_rcps > 0:
               avg_rcps_list.append(avg_rcps)
           if avg_scps > 0:
               avg_scps_list.append(avg_scps)

       print("-" * 77)

       overall_avg_rcps = (sum(avg_rcps_list) / len(avg_rcps_list)
                          if avg_rcps_list else 0)
       overall_avg_scps = (sum(avg_scps_list) / len(avg_scps_list)
                          if avg_scps_list else 0)

       total_traffic = total_sent + total_recv
       print(f"Total Received : {self.format_bytes(total_recv):>16}     "
             f"Total Sessions   : {self.total_sessions:>16}")
       print(f"Total Sent     : {self.format_bytes(total_sent):>16}     "
             f"Average CPS In   : {overall_avg_rcps:>16.2f}")
       print(f"Total Traffic  : {self.format_bytes(total_traffic):>16}"
             f"     Average CPS Out  : {overall_avg_scps:>16.2f}")
       print("-" * 77)
       print()

   def export_json(self, output_file: str):
       """Export statistics to JSON format"""
       start = self.start_date.isoformat() if self.start_date else None
       end = self.end_date.isoformat() if self.end_date else None
       data = {
           'start_date': start,
           'end_date': end,
           'days_filter': self.days,
           'total_sessions': self.total_sessions,
           'nodes': {}
       }

       for addr, s in self.stats.items():
           data['nodes'][addr] = {
               'sessions': s['sessions'],
               'sent_bytes': s['sent_bytes'],
               'recv_bytes': s['recv_bytes'],
               'sent_files': s['sent_files'],
               'recv_files': s['recv_files'],
               'avg_recv_cps': self.calculate_avg_cps(s['recv_cps']),
               'avg_send_cps': self.calculate_avg_cps(s['send_cps'])
           }

       with open(output_file, 'w') as f:
           json.dump(data, f, indent=2)

       print(f"Statistics exported to {output_file}")

   def export_csv(self, output_file: str):
       """Export statistics to CSV format"""
       with open(output_file, 'w') as f:
           f.write("Address,Sessions,Sent_Bytes,Recv_Bytes,Sent_Files,"
                  "Recv_Files,Avg_Send_CPS,Avg_Recv_CPS\n")

           sorted_addrs = sorted(self.stats.keys(),
                               key=lambda x: self.parse_fido_address(x))

           for addr in sorted_addrs:
               s = self.stats[addr]
               avg_rcps = self.calculate_avg_cps(s['recv_cps'])
               avg_scps = self.calculate_avg_cps(s['send_cps'])

               f.write(f"{addr},{s['sessions']},{s['sent_bytes']},"
                      f"{s['recv_bytes']},{s['sent_files']},"
                      f"{s['recv_files']},{avg_scps:.2f},{avg_rcps:.2f}\n")

       print(f"Statistics exported to {output_file}")


def main():
   parser = argparse.ArgumentParser(
       description='BinkD-Stats 2.0 - BinkD Log Analyzer',
       formatter_class=argparse.RawDescriptionHelpFormatter,
       epilog="""
Examples:
 %(prog)s -f /var/log/binkd.log
 %(prog)s -f /var/log/binkd.log -d 7
 %(prog)s -f /var/log/binkd.log --json stats.json
 %(prog)s -f /var/log/binkd.log --csv stats.csv -d 30
       """
   )

   parser.add_argument('-f', '--file', required=True,
                      help='Path to binkd.log file')
   parser.add_argument('-d', '--days', type=int, default=0,
                      help='Get statistics for last N days (0 = all)')
   parser.add_argument('--json', metavar='FILE',
                      help='Export statistics to JSON file')
   parser.add_argument('--csv', metavar='FILE',
                      help='Export statistics to CSV file')
   parser.add_argument('--version', action='version', version='%(prog)s 2.0')

   args = parser.parse_args()

   try:
       analyzer = BinkDStats(args.file, args.days)
       analyzer.parse_log()
       analyzer.print_text_report()

       if args.json:
           analyzer.export_json(args.json)

       if args.csv:
           analyzer.export_csv(args.csv)

   except FileNotFoundError as e:
       print(f"Error: {e}", file=sys.stderr)
       sys.exit(1)
   except Exception as e:
       print(f"Error: {e}", file=sys.stderr)
       import traceback
       traceback.print_exc()
       sys.exit(2)


if __name__ == '__main__':
   main()
=== Cut ===



--- GoldED+/LNX 1.1.5-b20250409
* Origin: Dragon's Lair ---:- dragon.vk3heg.net -:--- Prt: 6800 (3:633/280)