QgsFeatures fail to add to QgsVectorLayer

As far as I can see there are several problems in your code

Issue 1: Geometry/Layer type mismatch

Your layer is declared as "Point" but you're adding QgsGeometry.fromPolyline(...) geometries to it. QGIS silently rejects features whose geometry type doesn't match the layer type, hence result: False with no error message.

# Declares a LineString (polyline) layer
self.vectorlayer = QgsVectorLayer("LineString", "mylayer", "memory")

# If your points have Z coordinates (which yours do), use:
self.vectorlayer = QgsVectorLayer("LineStringZ", "mylayer", "memory")

Issue 2: Fields are never registered with the provider

In your working point example you noticed the fix yourself. You must call dataprovider.addAttributes() and self.vectorlayer.updateFields() before adding features. Without this the fields only exist on the QgsFields object you pass to QgsFeature, but the layer's data provider doesn't know about them, so attribute writes silently fail too.

def handleFileDrop(self, file):
    # read your data 
    print(len(ls), "lines")

    # 1. Create as LineStringZ (matches QgsPoint with x, y, z)
    self.vectorlayer = QgsVectorLayer("LineStringZ", "mylayer", "memory")
    dataprovider = self.vectorlayer.dataProvider()

    # 2. Register fields with the provider first
    dataprovider.addAttributes([
        QgsField('name', QVariant.String),
        QgsField('id',   QVariant.Int),
        QgsField('date', QVariant.Int),
    ])
    self.vectorlayer.updateFields()          # sync layer & provider

    # 3. Build features using the layer's own field definition
    fields = self.vectorlayer.fields()
    features = []

    for l in ls:
        feat = QgsFeature(fields)
        pts  = [QgsPoint(p.x, p.y, p.z) for p in l.points]
        feat.setGeometry(QgsGeometry.fromPolyline(pts))
        feat.setAttributes([l.name, l.id, l.date])
        features.append(feat)

    result, new_feats = dataprovider.addFeatures(features)
    print("result:", result, "-", len(new_feats), "new features")

    self.vectorlayer.updateExtents()
    print(dataprovider.featureCount(), "features")

    QgsProject.instance().addMapLayer(self.vectorlayer)
    self.iface.mapCanvas().refresh()

Note: A polyline is a single feature, its vertices are just coordinates with no attribute table rows of their own, so there's no standard way to attach id/time per vertex inside a LineString layer.

You still go through a provider, that hasn't changed. What has changed is the preferred pattern. Rather than keeping a QgsVectorDataProvider reference around and calling startEditing()/commitChanges() manually, the modern idiomatic approaches are:

Option A: with edit context manager

layer = QgsVectorLayer("Point?crs=EPSG:4326&field=name:string", "my_layer", "memory")

# Access the provider once to define fields — no need to keep the reference
layer.dataProvider().addAttributes([QgsField("name", QVariant.String)])
layer.updateFields()

with edit(layer):  # handles startEditing + commitChanges (+ rollback on error)
    feature = QgsFeature(layer.fields())
    feature.setGeometry(QgsGeometry.fromPointXY(QgsPointXY(8.0, 49.0)))
    feature.setAttribute("name", "test")
    layer.addFeature(feature)

with edit calls startEditing() on enter and commitChanges() on exit, and rolls back cleanly if an exception is raised. No manual bookkeeping needed.

Option B: dataProvider().addFeatures() directly

It bypasses the edit buffer entirely and is faster for bulk-loading a scratch layer you're not going to edit interactively:

layer.dataProvider().addFeatures([feature1, feature2])
layer.updateExtents()

For a temporary/memory layer you're just populating once, Option B is fine. For layers where you want undo/redo support or signals to fire properly, use with edit.

QgsVectorLayer(..., "memory") vs QgsMemoryProviderUtils.createMemoryLayer()

Functionally they produce the same thing - a memory-backed layer. The difference is ergonomics:

So it's mostly a convenience wrapper, useful when you already have a QgsFields object (e.g. copied from another layer).

Connecting Points While Keeping Them Interactive

A few options depending on your use case:

1. Two layers: A Point layer with all your attributes and interactivity, plus a virtual LineString layer purely as a visual connector.

2. Geometry Generator symbology: Keep only your Point layer and add a Geometry Generator symbol layer to it. You can write an expression that draws a line connecting the points dynamically, zero extra data management.

3. QgsCompoundCurve / QgsCircularString: These let you build geometrically connected curves, but they're single-feature geometries, so you'd lose per-point attribute storage and individual interactivity. Probably not what you want here.

For most use cases, the Geometry Generator approach: all your data lives in one place, points remain individually selectable and attribute-bearing, and the connecting line is just a rendering artefact.

References:

• QgsVectorLayer vs QgsVectorDataProvider for addFeatures() function in QGIS