diff --git a/providers/pcep/tunnel/src/main/java/org/onosproject/provider/pcep/tunnel/impl/PcepTunnelProvider.java b/providers/pcep/tunnel/src/main/java/org/onosproject/provider/pcep/tunnel/impl/PcepTunnelProvider.java
index 152a388..648e500 100644
--- a/providers/pcep/tunnel/src/main/java/org/onosproject/provider/pcep/tunnel/impl/PcepTunnelProvider.java
+++ b/providers/pcep/tunnel/src/main/java/org/onosproject/provider/pcep/tunnel/impl/PcepTunnelProvider.java
@@ -16,7 +16,9 @@
 package org.onosproject.provider.pcep.tunnel.impl;
 
 import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Strings.isNullOrEmpty;
 import static org.onosproject.net.DefaultAnnotations.EMPTY;
+import static org.onlab.util.Tools.get;
 import static org.onosproject.net.DeviceId.deviceId;
 import static org.onosproject.net.PortNumber.portNumber;
 import static org.onosproject.pcep.api.PcepDpid.uri;
@@ -24,24 +26,29 @@
 
 import java.util.ArrayList;
 import java.util.Collections;
+import java.util.Dictionary;
 import java.util.HashMap;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.ListIterator;
 import java.util.Optional;
 
+import com.google.common.collect.Maps;
 import org.apache.felix.scr.annotations.Activate;
 import org.apache.felix.scr.annotations.Component;
 import org.apache.felix.scr.annotations.Deactivate;
+import org.apache.felix.scr.annotations.Property;
 import org.apache.felix.scr.annotations.Reference;
 import org.apache.felix.scr.annotations.ReferenceCardinality;
 import org.apache.felix.scr.annotations.Service;
 import org.onlab.packet.IpAddress;
+import org.onosproject.cfg.ComponentConfigService;
 import org.onosproject.core.DefaultGroupId;
 import org.onosproject.incubator.net.tunnel.DefaultOpticalTunnelEndPoint;
 import org.onosproject.incubator.net.tunnel.DefaultTunnel;
 import org.onosproject.incubator.net.tunnel.DefaultTunnelDescription;
 import org.onosproject.incubator.net.tunnel.IpTunnelEndPoint;
+import org.onosproject.incubator.net.tunnel.DefaultTunnelStatistics;
 import org.onosproject.incubator.net.tunnel.OpticalLogicId;
 import org.onosproject.incubator.net.tunnel.OpticalTunnelEndPoint;
 import org.onosproject.incubator.net.tunnel.Tunnel;
@@ -52,6 +59,8 @@
 import org.onosproject.incubator.net.tunnel.TunnelProvider;
 import org.onosproject.incubator.net.tunnel.TunnelProviderRegistry;
 import org.onosproject.incubator.net.tunnel.TunnelProviderService;
+import org.onosproject.incubator.net.tunnel.TunnelService;
+import org.onosproject.incubator.net.tunnel.TunnelStatistics;
 import org.onosproject.net.ConnectPoint;
 import org.onosproject.net.DefaultAnnotations;
 import org.onosproject.net.DefaultLink;
@@ -73,6 +82,8 @@
 import org.onosproject.pcep.api.PcepTunnel.PATHTYPE;
 import org.onosproject.pcep.api.PcepTunnel.PathState;
 import org.onosproject.pcep.api.PcepTunnelListener;
+import org.onosproject.pcep.api.PcepTunnelStatistics;
+import org.osgi.service.component.annotations.Modified;
 import org.onosproject.pcep.controller.PccId;
 import org.onosproject.pcep.controller.PcepClient;
 import org.onosproject.pcep.controller.PcepClientController;
@@ -99,8 +110,7 @@
 import org.onosproject.pcepio.types.StatefulIPv4LspIdentidiersTlv;
 import org.onosproject.pcepio.types.SymbolicPathNameTlv;
 import org.slf4j.Logger;
-
-import static org.onosproject.pcep.api.PcepDpid.*;
+import org.osgi.service.component.ComponentContext;
 
 /**
  * Provider which uses an PCEP controller to detect, update, create network
@@ -116,6 +126,11 @@
     private static final String BANDWIDTH_UINT = "kbps";
     static final String PROVIDER_ID = "org.onosproject.provider.tunnel.pcep";
 
+    static final int POLL_INTERVAL = 10;
+    @Property(name = "tunnelStatsPollFrequency", intValue = POLL_INTERVAL,
+            label = "Frequency (in seconds) for polling tunnel statistics")
+    private int tunnelStatsPollFrequency = POLL_INTERVAL;
+
     private static final String TUNNLE_NOT_NULL = "Create failed,The given port may be wrong or has been occupied.";
 
     @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
@@ -126,9 +141,18 @@
 
     @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
     protected PcepClientController pcepClientController;
+
+    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+    protected TunnelService tunnelService;
+
+    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+    protected ComponentConfigService cfgService;
+
     TunnelProviderService service;
 
     HashMap<String, TunnelId> tunnelMap = new HashMap<String, TunnelId>();
+    HashMap<TunnelId, TunnelStatistics> tunnelStatisticsMap = new HashMap<>();
+    private HashMap<Long, TunnelStatsCollector> collectors = Maps.newHashMap();
 
     private InnerTunnelProvider listener = new InnerTunnelProvider();
 
@@ -144,10 +168,19 @@
 
     @Activate
     public void activate() {
+        cfgService.registerProperties(getClass());
         service = tunnelProviderRegistry.register(this);
         controller.addTunnelListener(listener);
         pcepClientController.addListener(listener);
         pcepClientController.addEventListener(listener);
+        tunnelService.queryAllTunnels().forEach(tunnel -> {
+            String pcepTunnelId = getPCEPTunnelKey(tunnel.tunnelId());
+            TunnelStatsCollector tsc = new TunnelStatsCollector(pcepTunnelId, tunnelStatsPollFrequency);
+            tsc.start();
+            collectors.put(tunnel.tunnelId().id(), tsc);
+
+        });
+
         log.info("Started");
     }
 
@@ -155,10 +188,31 @@
     public void deactivate() {
         tunnelProviderRegistry.unregister(this);
         controller.removeTunnelListener(listener);
+        collectors.values().forEach(TunnelStatsCollector::stop);
         pcepClientController.removeListener(listener);
         log.info("Stopped");
     }
 
+    @Modified
+    public void modified(ComponentContext context) {
+        Dictionary<?, ?> properties = context.getProperties();
+        int newTunnelStatsPollFrequency;
+        try {
+            String s = get(properties, "tunnelStatsPollFrequency");
+            newTunnelStatsPollFrequency = isNullOrEmpty(s) ? tunnelStatsPollFrequency : Integer.parseInt(s.trim());
+
+        } catch (NumberFormatException | ClassCastException e) {
+            newTunnelStatsPollFrequency = tunnelStatsPollFrequency;
+        }
+
+        if (newTunnelStatsPollFrequency != tunnelStatsPollFrequency) {
+            tunnelStatsPollFrequency = newTunnelStatsPollFrequency;
+            collectors.values().forEach(tsc -> tsc.adjustPollInterval(tunnelStatsPollFrequency));
+            log.info("New setting: tunnelStatsPollFrequency={}", tunnelStatsPollFrequency);
+        }
+
+    }
+
     @Override
     public void setupTunnel(Tunnel tunnel, Path path) {
         if (tunnel.type() != Tunnel.Type.MPLS) {
@@ -177,7 +231,7 @@
 
         if (!(pc instanceof PcepClient)) {
             log.error("There is no PCC connected with ip addresss {}"
-                    + ((IpTunnelEndPoint) tunnel.src()).ip().toString());
+                              + ((IpTunnelEndPoint) tunnel.src()).ip().toString());
             return;
         }
         pcepSetupTunnel(tunnel, path, pc);
@@ -581,6 +635,21 @@
     }
 
     /**
+     * Build a DefaultTunnelStatistics from a PcepTunnelStatistics.
+     *
+     * @param statistics statistics data from a PCEP tunnel
+     * @return TunnelStatistics
+     */
+    private TunnelStatistics buildTunnelStatistics(PcepTunnelStatistics statistics) {
+        DefaultTunnelStatistics.Builder builder = new DefaultTunnelStatistics.Builder();
+        DefaultTunnelStatistics tunnelStatistics =  builder.setBwUtilization(statistics.bandwidthUtilization())
+                    .setPacketLossRatio(statistics.packetLossRate())
+                    .setFlowDelay(statistics.flowDelay())
+                    .setAlarms(statistics.alarms())
+                .build();
+        return tunnelStatistics;
+   }
+    /**
      * Creates list of hops for ERO object from Path.
      *
      * @param path network path
@@ -844,6 +913,8 @@
         }
     }
 
+
+
     private class InnerTunnelProvider implements PcepTunnelListener, PcepEventListener, PcepClientListener {
 
         @Override
@@ -1141,6 +1212,15 @@
         public void clientDisconnected(PccId pccId) {
             // TODO
         }
+
+
+
+        @Override
+        public void handlePcepTunnelStatistics(PcepTunnelStatistics pcepTunnelStatistics) {
+            TunnelId id = getTunnelId(String.valueOf(pcepTunnelStatistics.id()));
+            TunnelStatistics tunnelStatistics = buildTunnelStatistics(pcepTunnelStatistics);
+            tunnelStatisticsMap.put(id, tunnelStatistics);
+        }
     }
 
     @Override
diff --git a/providers/pcep/tunnel/src/main/java/org/onosproject/provider/pcep/tunnel/impl/TunnelStatsCollector.java b/providers/pcep/tunnel/src/main/java/org/onosproject/provider/pcep/tunnel/impl/TunnelStatsCollector.java
new file mode 100644
index 0000000..39249c5
--- /dev/null
+++ b/providers/pcep/tunnel/src/main/java/org/onosproject/provider/pcep/tunnel/impl/TunnelStatsCollector.java
@@ -0,0 +1,104 @@
+/*
+ *
+ *  * Copyright 2014-2015 Open Networking Laboratory
+ *  *
+ *  * Licensed under the Apache License, Version 2.0 (the "License");
+ *  * you may not use this file except in compliance with the License.
+ *  * You may obtain a copy of the License at
+ *  *
+ *  *     http://www.apache.org/licenses/LICENSE-2.0
+ *  *
+ *  * Unless required by applicable law or agreed to in writing, software
+ *  * distributed under the License is distributed on an "AS IS" BASIS,
+ *  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  * See the License for the specific language governing permissions and
+ *  * limitations under the License.
+ *
+ */
+
+package org.onosproject.provider.pcep.tunnel.impl;
+
+
+import org.apache.felix.scr.annotations.Reference;
+import org.apache.felix.scr.annotations.ReferenceCardinality;
+import org.jboss.netty.util.HashedWheelTimer;
+import org.jboss.netty.util.Timeout;
+import org.jboss.netty.util.TimerTask;
+import org.onlab.util.Timer;
+import org.onosproject.pcep.api.PcepController;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.concurrent.TimeUnit;
+
+/*
+ * Sends Stats Request and collect the tunnel statistics with a time interval.
+ */
+public class TunnelStatsCollector implements TimerTask {
+    private final Logger log = LoggerFactory.getLogger(getClass());
+
+    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+    protected PcepController controller;
+
+    private int refreshInterval;
+    private final HashedWheelTimer timer = Timer.getTimer();
+
+    private String pcepTunnelId;
+    private Timeout timeout;
+    private volatile boolean stopped;
+
+
+    /**
+     * Greate a tunnel status collector object.
+     *
+     * @param id              tunnel whose status data will be collected
+     * @param refreshInterval time interval for collecting statistic
+     */
+    public TunnelStatsCollector(String id, int refreshInterval) {
+        this.pcepTunnelId = id;
+        this.refreshInterval = refreshInterval;
+    }
+
+    @Override
+    public void run(Timeout timeout) throws Exception {
+        if (stopped || timeout.isCancelled()) {
+            return;
+        }
+        log.trace("Collecting stats for {}", pcepTunnelId);
+
+        sendTunnelStatistic();
+        if (!stopped && !timeout.isCancelled()) {
+            log.trace("Scheduling stats collection in {} seconds for {}",
+                      this.refreshInterval, pcepTunnelId);
+            timeout.getTimer().newTimeout(this, refreshInterval, TimeUnit.SECONDS);
+        }
+
+    }
+
+    private void sendTunnelStatistic() {
+        controller.getTunnelStatistics(pcepTunnelId);
+
+    }
+
+    synchronized void adjustPollInterval(int pollInterval) {
+        this.refreshInterval = pollInterval;
+    }
+
+    /**
+     * Starts the collector.
+     */
+    public synchronized void start() {
+        log.info("Starting Tunnel Stats collection thread for {}", pcepTunnelId);
+        stopped = false;
+        timeout = timer.newTimeout(this, 1, TimeUnit.SECONDS);
+    }
+
+    /**
+     * Stops the collector.
+     */
+    public synchronized void stop() {
+        log.info("Stopping Tunnel Stats collection thread for {}", pcepTunnelId);
+        stopped = true;
+        timeout.cancel();
+    }
+}