#!/usr/bin/perl
use warnings;
use strict;
use feature qw{ say };

use XML::LibXML::Reader;


my $r = 'XML::LibXML::Reader'->new(location => shift);
say 'time|resourceGroup|LCONNFAIL|LLOSTCONN|LIDLETIMEOUT|SIPADDR|SIPPO
+RT';

my %dispatch = (
    statRecord => sub {
        print $r->getAttribute('time'), '|';
    },
    resourceGroup => sub {
        print $r->getAttribute('name');
    },
    name => sub {
        my $name = $r->readInnerXml;
        return unless $name
            =~ /^(?:LCONNFAIL|LLOSTCONN|LIDLETIMEOUT|SIPADDR|SIPPORT)$
+/;
        $r->nextSiblingElement('value');
        print '|', $r->readInnerXml;
        print "\n" if $name eq 'SIPPORT';
    }
);

while ($r->read) {
    next unless $r->nodeType == 1;
    my $action = $dispatch{ $r->name };
    $action->() if $action;
}
[download]

@choroba , your code works flawless too ! Thanks for your support and not least for your teachings.

Try building a hash from the name/value elements within each resourceGroup. Example using XML::Twig

#!/usr/bin/perl
use strict;
use XML::Twig;

#time|resourceGroup name|LCONNFAIL|LLOSTCONN|LIDLETIMEOUT|SIPADDR|SIPP
+ORT
my @columns = ('resourceGroup',
'LCONNFAIL','LLOSTCONN','LIDLETIMEOUT','SIPADDR','SIPPORT');
my $time;
my %record = ();

# tag handler
my $twig = XML::Twig->new(   
  twig_handlers => 
   { 
     resourceGroup => \&resourceGroup,
     statistic     => \&statistic,
   },
  start_tag_handlers => {
     statRecord => sub { $time = $_[1]->att('time') }
  }   
);

# process file
print join '|','time',@columns;
print "\n";
$twig->parsefile( 'my_file.xml' );

sub resourceGroup {
  my ($t,$e) = @_;
  $record{'resourceGroup'} = $e->att('name');
  
  # print record
  print join "|",$time,map{$record{$_}}@columns;
  print "\n";
  $t->purge;
  %record = ();
}

sub statistic {
  my ($t,$e) = @_;
  my $name       = $e->first_child_text('name');
  $record{$name} = $e->first_child_text('value');
}
[download]

@Poj your code work flawless !
Thanks for your support!!!!.
And overall, thanks for teaching me how to interact correctly with the xml file

How did your approaches fail? You already managed to read in the data, as your output using Data::Dumper shows, so where is your problem?

Is your problem to output the CSV / pipe delimited data?

Can you please edit your post and add the code you already have, and explain where exactly your problem is?

Hi Corion, thanks for your fast reply. My issue is to accesso to data/field. I'm not able to print this field/value:

2019-07-16T08:23:59|CSCS1SVGM1|0|0|0|amlif700txs001|28218
[download]

Again, please show us the code you already have, and also explain to us where each value comes from.

Without seeing the code you already have, it is very hard to give you concrete advice on how to change your code.

Thanks for your time Bill. As explained above, the Poj's solution is really fine and works flawless.

I understand that poj showed you how to parse the file. You still have the discrepancy in the file size. Are you sure that this is not a symptom of another problem?
Bill

To add to the list of options...

use strict;
use XML::Rules;
use Data::Dumper qw(Dumper);

my $parser = XML::Rules->new(
    stripspaces => 15,
    rules => {
        'name,value' => 'content',
        statistic => sub { return '%' . $_[1]->{type} => { $_[1]->{nam
+e} => $_[1]->{value}} },
        resourceGroup => 'no content array',
        statRecord => sub {
            #print Dumper($_[1]);
            
            foreach my $group (@{$_[1]->{resourceGroup}}) {
                print "$_[1]->{time}|$group->{name}|$group->{Lifetime}
+{LCONNFAIL}|$group->{Lifetime}{LLOSTCONN}|$group->{Lifetime}{LIDLETIM
+EOUT}|$group->{Startup}{SIPADDR}|$group->{Startup}{SIPPORT}\n";
            }
            return;
        }
    }
);

print "time|resourceGroup name|LCONNFAIL|LLOSTCONN|LIDLETIMEOUT|SIPADD
+R|SIPPORT\n";

$parser->parse(\*DATA);

__DATA__
<?xml version="1.0" encoding="UTF-8"?>
<ctgStatistics xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
   xsi:noNamespaceSchemaLocation="ctgstatslog.xsd">
   <statRecord type="interval" length="60" time="2019-07-16T08:23:59">
      <resourceGroup name="CSCS1SVGM1">
         <statistic type="Startup">
...
[download]

use strict;
use XML::Rules;
use Data::Dumper qw(Dumper);

my $parser = XML::Rules->new(
    stripspaces => 15,
    rules => {
        'name,value' => 'content',
        statistic => sub { return $_[1]->{name} => $_[1]->{value} },
        resourceGroup => 'no content array',
        statRecord => sub {
            #print Dumper($_[1]);
            
            foreach my $group (@{$_[1]->{resourceGroup}}) {
                print "$_[1]->{time}|$group->{name}|$group->{LCONNFAIL
+}|$group->{LLOSTCONN}|$group->{LIDLETIMEOUT}|$group->{SIPADDR}|$group
+->{SIPPORT}\n";
            }
            return;
        }
    }
);

print "time|resourceGroup name|LCONNFAIL|LLOSTCONN|LIDLETIMEOUT|SIPADD
+R|SIPPORT\n";

$parser->parse(\*DATA);

__DATA__
<?xml version="1.0" encoding="UTF-8"?>
<ctgStatistics xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
   xsi:noNamespaceSchemaLocation="ctgstatslog.xsd">
   <statRecord type="interval" length="60" time="2019-07-16T08:23:59">
      <resourceGroup name="CSCS1SVGM1">
         <statistic type="Startup">
...
[download]

The first version preserves the statistics type in the data provided to the handler of the statRecord tag, the second assumes there will be no duplicate names of statistics and ignores the types.

There's only the data from one <statRecord> in memory at any time.

Thanks Jenda!!

XML::LibXML can do it as well, as was shown here in this very thread. XML::LibXML::Reader works similarly to XML::Twig - it doesn't keep the whole data in memory, but if you tell it to, it can "inflate" a part of the data into a full-featured XML::LibXML™ object you can process using all the available methods.
map{substr$_->[0],$_->[1]||0,1}[\*||{},3],[[]],[ref qr-1,-,-1],[{}],[sub{}^*ARGV,3]

Well, yes but no.

There are more ways and often your hailed "industry-standard binary libraries" support several.

You can use one of several libraries to load the whole file into memory as a huge maze of objects and then search and navigate the maze using methods and sublanguages like XPath.

You can use one of several libraries to load the whole file into memory as a huge memory structure (possibly with a bit of tie() magic) and navigate it using normal Perl tools. You should NOT use XML::Simple for that 'cause it produces inconsistent data structures! If the data structure is your goal, then have a look at XML::Rules, it would allow you to produce a consistent structure and trim it along the way.

You can use one of several libraries to have them call your handlers whenever they find another bit of whatever in the XML and take care of knowing where the heck you are in the structure yourself. Good luck with that! Industry standard or no industry standard. It's a mess.

You can use one of several libraries to give you the next bit whenever you ask for it and take care of knowing where the heck you are in the structure yourself. Good luck with that! Industry standard or no industry standard. It's a mess.

You can use XML::Twig to call your handler whenever it finishes parsing a reasonably large, easy to digest chunk of the XML (a twig) and have it provide you with the data from the twig either as a maze of objects or a data structure.

You can use XML::Rules to call your handler whenever it finishes parsing a reasonably large, easy to digest chunk of the XML and have it provide you with the data from the chunk as a data structure built according to the rules you provided, handle or massage the data in any way you need and have the result made available to the handler of an enclosing chunk and thus either process the file as you go or build a modified, trimmed down data structure.

Jenda
Enoch was right!
Enjoy the last years of Rome.

Thanks for your tips.