diff --git a/helper/tracers/ccnx-path-weight-tracer.cc b/helper/tracers/ccnx-path-weight-tracer.cc
new file mode 100644
index 0000000..d1cb709
--- /dev/null
+++ b/helper/tracers/ccnx-path-weight-tracer.cc
@@ -0,0 +1,81 @@
+/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil -*- */
+/*
+ * Copyright (c) 2011 UCLA
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation;
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ * Author:  Alexander Afanasyev <alexander.afanasyev@ucla.edu>
+ */
+
+#include "ccnx-path-weight-tracer.h"
+#include "ns3/node.h"
+#include "ns3/packet.h"
+#include "ns3/config.h"
+#include "ns3/names.h"
+#include "ns3/callback.h"
+#include "ns3/ccnx-app.h"
+#include "ns3/ccnx-face.h"
+#include "ns3/boolean.h"
+
+#include <boost/lexical_cast.hpp>
+#include <boost/foreach.hpp>
+
+using namespace std;
+
+namespace ns3 {
+    
+CcnxPathWeightTracer::CcnxPathWeightTracer (std::ostream &os, Ptr<Node> node, std::string appId)
+  : m_os (os)
+  , m_nodePtr (node)
+  , m_appId (appId)
+{
+  m_node = boost::lexical_cast<string> (m_nodePtr->GetId ());
+
+  Connect ();
+
+  string name = Names::FindName (node);
+  if (!name.empty ())
+    {
+      m_node = name;
+    }
+}
+
+void
+CcnxPathWeightTracer::Connect ()
+{
+  Config::Set ("/NodeList/"+m_node+"/$ns3::CcnxL3Protocol/ForwardingStrategy/MetricTagging",
+               BooleanValue (true));
+
+  Config::Connect ("/NodeList/"+m_node+"/$ns3::CcnxL3Protocol/FaceList/*/$ns3::CcnxLocalFace/PathWeightsTrace",
+                   MakeCallback (&CcnxPathWeightTracer::InLocalFace, this));
+}
+
+
+void
+CcnxPathWeightTracer::PrintHeader (std::ostream &os) const
+{
+  os << "Node\t"
+     << "AppId\t"
+     << "PathWeight\t"
+     << "PathWeights\n";
+}
+
+void
+CcnxPathWeightTracer::InLocalFace (std::string context,
+                                   uint32_t weight, Ptr<Node> src, Ptr<Node> dst)
+{
+  std::cout << "Path weights from " << Names::FindName (src) << " to "<< Names::FindName (dst) <<" : " << weight << "\n";
+}
+
+} // namespace ns3
diff --git a/helper/tracers/ccnx-path-weight-tracer.h b/helper/tracers/ccnx-path-weight-tracer.h
new file mode 100644
index 0000000..ca43a5d
--- /dev/null
+++ b/helper/tracers/ccnx-path-weight-tracer.h
@@ -0,0 +1,63 @@
+/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil -*- */
+/*
+ * Copyright (c) 2011 UCLA
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation;
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ * Author:  Alexander Afanasyev <alexander.afanasyev@ucla.edu>
+ */
+
+#ifndef CCNX_PATH_WEIGHT_TRACER_H
+#define CCNX_PATH_WEIGHT_TRACER_H
+
+#include "ns3/ptr.h"
+#include "ns3/simple-ref-count.h"
+#include "ns3/ccnx-path-stretch-tag.h"
+#include <list>
+
+namespace ns3 {
+
+class Node;
+class Packet;
+class CcnxApp;
+
+class CcnxPathWeightTracer : public SimpleRefCount<CcnxPathWeightTracer>
+{
+public:
+  CcnxPathWeightTracer (std::ostream &os, Ptr<Node> node, std::string appId);
+  virtual ~CcnxPathWeightTracer () { };
+
+  void
+  Connect ();
+  
+  virtual void
+  PrintHeader (std::ostream &os) const;
+
+  /**
+   * \brief Process packet weight upon reception of packet on a local face
+   */
+  virtual void
+  InLocalFace (std::string context,
+               uint32_t weight, Ptr<Node> src, Ptr<Node> dst);
+
+protected:
+  std::ostream &m_os;
+  std::string m_node;
+  Ptr<Node> m_nodePtr;
+  std::string m_appId;
+};
+
+} // namespace ns3
+
+#endif // CCNX_PATH_WEIGHT_TRACER_H
